diff --git a/crates/analyzer/src/analyzer.rs b/crates/analyzer/src/analyzer.rs index ad0b1a19..1d76b64e 100644 --- a/crates/analyzer/src/analyzer.rs +++ b/crates/analyzer/src/analyzer.rs @@ -1,4 +1,3 @@ -pub mod check_variable_type; use crate::analyzer::resource_table::PathId; use crate::analyzer_error::AnalyzerError; use crate::assign::{AssignPath, AssignPosition, AssignPositionTree, AssignPositionType}; @@ -13,7 +12,6 @@ use crate::symbol::{ }; use crate::symbol_table; use crate::type_dag; -use check_variable_type::*; use itertools::Itertools; use std::path::Path; use veryl_metadata::{Build, Lint, Metadata}; @@ -75,12 +73,6 @@ impl<'a> AnalyzerPass3<'a> { } } - pub fn check_variable_type(&self, input: &Veryl) -> Vec { - let mut check_variable_type = CheckVariableType::new(self.text); - check_variable_type.veryl(input); - check_variable_type.errors - } - pub fn check_variables(&self) -> Vec { let mut ret = Vec::new(); @@ -245,13 +237,12 @@ impl Analyzer { project_name: &str, text: &str, path: T, - input: &Veryl, + _input: &Veryl, ) -> Vec { let mut ret = Vec::new(); namespace_table::set_default(&[project_name.into()]); let pass3 = AnalyzerPass3::new(path.as_ref(), text); - ret.append(&mut pass3.check_variable_type(input)); ret.append(&mut pass3.check_variables()); ret.append(&mut pass3.check_assignment()); @@ -386,7 +377,7 @@ fn traverse_assignable_symbol(id: SymbolId, path: &AssignPath) -> Vec { + SymbolKind::Port(x) if is_assignable(&x.direction) && !x.is_proto => { if let Some(ref x) = x.r#type { if let TypeKind::UserDefined(ref x) = x.kind { if let Ok(symbol) = symbol_table::resolve((x, &symbol.namespace)) { diff --git a/crates/analyzer/src/analyzer/check_variable_type.rs b/crates/analyzer/src/analyzer/check_variable_type.rs deleted file mode 100644 index 9d679139..00000000 --- a/crates/analyzer/src/analyzer/check_variable_type.rs +++ /dev/null @@ -1,191 +0,0 @@ -use crate::analyzer_error::AnalyzerError; -use crate::symbol::{GenericMap, Symbol, SymbolKind, TypeKind}; -use crate::symbol_path::GenericSymbolPath; -use crate::{namespace_table, symbol_table}; -use veryl_parser::veryl_grammar_trait::*; -use veryl_parser::veryl_walker::VerylWalker; - -#[derive(Default)] -pub struct CheckVariableType<'a> { - pub errors: Vec, - text: &'a str, - generic_maps: Vec, - in_variable_type: bool, -} - -impl<'a> CheckVariableType<'a> { - pub fn new(text: &'a str) -> Self { - Self { - text, - ..Default::default() - } - } -} - -fn is_variable_type(symbol: &Symbol) -> bool { - match &symbol.kind { - SymbolKind::Enum(_) - | SymbolKind::Union(_) - | SymbolKind::Struct(_) - | SymbolKind::TypeDef(_) - | SymbolKind::SystemVerilog => true, - SymbolKind::Parameter(x) => x.r#type.kind == TypeKind::Type, - SymbolKind::GenericInstance(x) => { - let base = symbol_table::get(x.base).unwrap(); - is_variable_type(&base) - } - _ => false, - } -} - -impl<'a> VerylWalker for CheckVariableType<'a> { - /// Semantic action for non-terminal 'StructUnionDeclaration' - fn struct_union_declaration(&mut self, arg: &StructUnionDeclaration) { - let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); - let maps = symbol.found.generic_maps(); - - for map in maps { - self.generic_maps.push(map.clone()); - self.struct_union_list(&arg.struct_union_list); - self.generic_maps.pop(); - } - } - - /// Semantic action for non-terminal 'FunctionDeclaration' - fn function_declaration(&mut self, arg: &FunctionDeclaration) { - let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); - let maps = symbol.found.generic_maps(); - - for map in maps { - self.generic_maps.push(map.clone()); - 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); - } - for x in &arg.function_declaration_list { - self.function_item(&x.function_item); - } - self.generic_maps.pop(); - } - } - - /// Semantic action for non-terminal 'ModuleDeclaration' - fn module_declaration(&mut self, arg: &ModuleDeclaration) { - let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); - let maps = symbol.found.generic_maps(); - - for map in maps { - self.generic_maps.push(map.clone()); - 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); - } - for x in &arg.module_declaration_list { - self.module_group(&x.module_group); - } - self.generic_maps.pop(); - } - } - - /// Semantic action for non-terminal 'InterfaceDeclaration' - fn interface_declaration(&mut self, arg: &InterfaceDeclaration) { - let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); - let maps = symbol.found.generic_maps(); - - for map in maps { - self.generic_maps.push(map.clone()); - if let Some(ref x) = arg.interface_declaration_opt1 { - self.with_parameter(&x.with_parameter); - } - for x in &arg.interface_declaration_list { - self.interface_group(&x.interface_group); - } - self.generic_maps.pop(); - } - } - - /// Semantic action for non-terminal 'PackageDeclaration' - fn package_declaration(&mut self, arg: &PackageDeclaration) { - let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); - let maps = symbol.found.generic_maps(); - - for map in maps { - self.generic_maps.push(map.clone()); - for x in &arg.package_declaration_list { - self.package_group(&x.package_group); - } - self.generic_maps.pop(); - } - } - - /// Semantic action for non-terminal 'VariableType' - fn variable_type(&mut self, arg: &VariableType) { - if let VariableTypeGroup::ScopedIdentifier(x) = &*arg.variable_type_group { - self.in_variable_type = true; - self.scoped_identifier(&x.scoped_identifier); - self.in_variable_type = false; - } - } - - /// Semantic action for non-terminal 'PortDeclarationItem' - fn port_declaration_item(&mut self, arg: &PortDeclarationItem) { - if let PortDeclarationItemGroup::PortTypeConcrete(x) = &*arg.port_declaration_item_group { - let x = x.port_type_concrete.as_ref(); - let is_modport = matches!(&*x.direction, Direction::Modport(_)); - if !is_modport { - self.array_type(&x.array_type); - } - } - } - - /// Semantic action for non-terminal 'ScopedIdentifier' - fn scoped_identifier(&mut self, arg: &ScopedIdentifier) { - if !self.in_variable_type { - return; - } - - let namespace = namespace_table::get(arg.identifier().token.id).unwrap(); - let mut path: GenericSymbolPath = arg.into(); - - for i in 0..path.len() { - let base_path = path.base_path(i); - if let Ok(symbol) = symbol_table::resolve((&base_path, &namespace)) { - let params = symbol.found.generic_parameters(); - let n_args = path.paths[i].arguments.len(); - - for param in params.iter().skip(n_args) { - path.paths[i] - .arguments - .push(param.1.as_ref().unwrap().clone()); - } - } - } - - path.apply_map(&self.generic_maps); - if let Ok(symbol) = symbol_table::resolve((&path.mangled_path(), &namespace)) { - if !is_variable_type(&symbol.found) { - self.errors.push(AnalyzerError::mismatch_type( - &symbol.found.token.to_string(), - "enum or union or struct", - &symbol.found.kind.to_kind_name(), - self.text, - &arg.identifier().token.into(), - )); - } - } else if !path.is_resolvable() { - let text = path.base_path(0).0[0].to_string(); - self.errors.push(AnalyzerError::mismatch_type( - &text, - "enum or union or struct", - &path.kind.to_string(), - self.text, - &arg.identifier().token.into(), - )); - } - } -} diff --git a/crates/analyzer/src/analyzer_error.rs b/crates/analyzer/src/analyzer_error.rs index 9140fad7..87c4b741 100644 --- a/crates/analyzer/src/analyzer_error.rs +++ b/crates/analyzer/src/analyzer_error.rs @@ -363,6 +363,23 @@ pub enum AnalyzerError { error_location: SourceSpan, }, + #[diagnostic( + severity(Error), + code(incompat_proto), + help(""), + url("https://doc.veryl-lang.org/book/07_appendix/02_semantic_error.html#incompat_proto") + )] + #[error("{identifier} is incompatible with {proto} because {cause}")] + IncompatProto { + identifier: String, + proto: String, + cause: String, + #[source_code] + input: NamedSource, + #[label("Error location")] + error_location: SourceSpan, + }, + #[diagnostic( severity(Error), code(missing_default_argument), @@ -1195,6 +1212,22 @@ impl AnalyzerError { } } + pub fn incompat_proto( + identifier: &str, + proto: &str, + cause: &str, + source: &str, + token: &TokenRange, + ) -> Self { + AnalyzerError::IncompatProto { + identifier: identifier.into(), + proto: proto.into(), + cause: cause.into(), + input: AnalyzerError::named_source(source, token), + error_location: token.into(), + } + } + pub fn missing_default_argument(identifier: &str, source: &str, token: &TokenRange) -> Self { AnalyzerError::MissingDefaultArgument { identifier: identifier.into(), diff --git a/crates/analyzer/src/handlers.rs b/crates/analyzer/src/handlers.rs index 91fc327a..03e0a2a7 100644 --- a/crates/analyzer/src/handlers.rs +++ b/crates/analyzer/src/handlers.rs @@ -8,11 +8,12 @@ pub mod check_enum; pub mod check_expression; pub mod check_function; pub mod check_identifier; -pub mod check_instance; pub mod check_modport; pub mod check_msb_lsb; pub mod check_number; +pub mod check_proto; pub mod check_statement; +pub mod check_type; pub mod check_unsafe; pub mod create_reference; pub mod create_symbol_table; @@ -26,11 +27,12 @@ use check_enum::*; use check_expression::*; use check_function::*; use check_identifier::*; -use check_instance::*; use check_modport::*; use check_msb_lsb::*; use check_number::*; +use check_proto::*; use check_statement::*; +use check_type::*; use check_unsafe::*; use create_reference::*; use create_symbol_table::*; @@ -97,7 +99,7 @@ pub struct Pass2Handlers<'a> { check_enum: CheckEnum<'a>, check_modport: CheckModport<'a>, check_function: CheckFunction<'a>, - check_instance: CheckInstance<'a>, + check_type: CheckType<'a>, check_msb_lsb: CheckMsbLsb<'a>, check_assignment: CheckAssignment<'a>, check_clock_reset: CheckClockReset<'a>, @@ -105,6 +107,7 @@ pub struct Pass2Handlers<'a> { create_type_dag: CreateTypeDag<'a>, check_expression: CheckExpression<'a>, check_clock_domain: CheckClockDomain<'a>, + check_proto: CheckProto<'a>, } impl<'a> Pass2Handlers<'a> { @@ -113,7 +116,7 @@ impl<'a> Pass2Handlers<'a> { check_enum: CheckEnum::new(text), check_modport: CheckModport::new(text), check_function: CheckFunction::new(text), - check_instance: CheckInstance::new(text), + check_type: CheckType::new(text), check_msb_lsb: CheckMsbLsb::new(text), check_assignment: CheckAssignment::new(text), check_clock_reset: CheckClockReset::new(text), @@ -121,6 +124,7 @@ impl<'a> Pass2Handlers<'a> { create_type_dag: CreateTypeDag::new(text), check_expression: CheckExpression::new(text), check_clock_domain: CheckClockDomain::new(text), + check_proto: CheckProto::new(text), } } @@ -129,7 +133,7 @@ impl<'a> Pass2Handlers<'a> { &mut self.check_enum as &mut dyn Handler, &mut self.check_modport as &mut dyn Handler, &mut self.check_function as &mut dyn Handler, - &mut self.check_instance as &mut dyn Handler, + &mut self.check_type as &mut dyn Handler, &mut self.check_msb_lsb as &mut dyn Handler, &mut self.check_assignment as &mut dyn Handler, &mut self.check_clock_reset as &mut dyn Handler, @@ -137,6 +141,7 @@ impl<'a> Pass2Handlers<'a> { &mut self.create_type_dag as &mut dyn Handler, &mut self.check_expression as &mut dyn Handler, &mut self.check_clock_domain as &mut dyn Handler, + &mut self.check_proto as &mut dyn Handler, ] } @@ -145,7 +150,7 @@ impl<'a> Pass2Handlers<'a> { ret.append(&mut self.check_enum.errors); ret.append(&mut self.check_modport.errors); ret.append(&mut self.check_function.errors); - ret.append(&mut self.check_instance.errors); + ret.append(&mut self.check_type.errors); ret.append(&mut self.check_msb_lsb.errors); ret.append(&mut self.check_assignment.errors); ret.append(&mut self.check_clock_reset.errors); @@ -153,6 +158,7 @@ impl<'a> Pass2Handlers<'a> { ret.append(&mut self.create_type_dag.errors); ret.append(&mut self.check_expression.errors); ret.append(&mut self.check_clock_domain.errors); + ret.append(&mut self.check_proto.errors); ret } } diff --git a/crates/analyzer/src/handlers/check_expression.rs b/crates/analyzer/src/handlers/check_expression.rs index baf9e369..437bc808 100644 --- a/crates/analyzer/src/handlers/check_expression.rs +++ b/crates/analyzer/src/handlers/check_expression.rs @@ -93,6 +93,7 @@ impl<'a> VerylGrammarTrait for CheckExpression<'a> { } } SymbolKind::Module(_) + | SymbolKind::ProtoModule(_) | SymbolKind::Interface(_) | SymbolKind::Instance(_) | SymbolKind::Block diff --git a/crates/analyzer/src/handlers/check_instance.rs b/crates/analyzer/src/handlers/check_instance.rs deleted file mode 100644 index 020e2ab0..00000000 --- a/crates/analyzer/src/handlers/check_instance.rs +++ /dev/null @@ -1,119 +0,0 @@ -use crate::analyzer_error::AnalyzerError; -use crate::attribute::AllowItem; -use crate::attribute::Attribute as Attr; -use crate::attribute_table; -use crate::symbol::SymbolKind; -use crate::symbol_table; -use veryl_parser::resource_table; -use veryl_parser::veryl_grammar_trait::*; -use veryl_parser::veryl_walker::{Handler, HandlerPoint, VerylWalker}; -use veryl_parser::{ParolError, Stringifier}; - -pub struct CheckInstance<'a> { - pub errors: Vec, - text: &'a str, - point: HandlerPoint, -} - -impl<'a> CheckInstance<'a> { - pub fn new(text: &'a str) -> Self { - Self { - errors: Vec::new(), - text, - point: HandlerPoint::Before, - } - } -} - -impl<'a> Handler for CheckInstance<'a> { - fn set_point(&mut self, p: HandlerPoint) { - self.point = p; - } -} - -impl<'a> VerylGrammarTrait for CheckInstance<'a> { - fn inst_declaration(&mut self, arg: &InstDeclaration) -> Result<(), ParolError> { - if let HandlerPoint::Before = self.point { - let mut connected_params = Vec::new(); - if let Some(ref x) = arg.inst_declaration_opt0 { - if let Some(ref x) = x.inst_parameter.inst_parameter_opt { - let items: Vec = x.inst_parameter_list.as_ref().into(); - for item in items { - connected_params.push(item.identifier.identifier_token.token.text); - } - } - } - - let mut connected_ports = Vec::new(); - if let Some(ref x) = arg.inst_declaration_opt1 { - if let Some(ref x) = x.inst_declaration_opt2 { - let items: Vec = x.inst_port_list.as_ref().into(); - for item in items { - connected_ports.push(item.identifier.identifier_token.token.text); - } - } - } - - if let Ok(symbol) = symbol_table::resolve(arg.scoped_identifier.as_ref()) { - let mut stringifier = Stringifier::new(); - stringifier.scoped_identifier(&arg.scoped_identifier); - let name = stringifier.as_str(); - match symbol.found.kind { - SymbolKind::Module(ref x) => { - for port in &x.ports { - if !connected_ports.contains(&port.name) - && !attribute_table::contains( - &arg.inst.inst_token.token, - Attr::Allow(AllowItem::MissingPort), - ) - { - let port = resource_table::get_str_value(port.name).unwrap(); - self.errors.push(AnalyzerError::missing_port( - name, - &port, - self.text, - &arg.identifier.as_ref().into(), - )); - } - } - for param in &connected_params { - if !x.parameters.iter().any(|x| &x.name == param) { - let param = resource_table::get_str_value(*param).unwrap(); - self.errors.push(AnalyzerError::unknown_param( - name, - ¶m, - self.text, - &arg.identifier.as_ref().into(), - )); - } - } - for port in &connected_ports { - if !x.ports.iter().any(|x| &x.name == port) { - let port = resource_table::get_str_value(*port).unwrap(); - self.errors.push(AnalyzerError::unknown_port( - name, - &port, - self.text, - &arg.identifier.as_ref().into(), - )); - } - } - } - SymbolKind::Interface(_) => (), - SymbolKind::SystemVerilog => (), - SymbolKind::GenericParameter(_) => (), - _ => { - self.errors.push(AnalyzerError::mismatch_type( - name, - "module or interface", - &symbol.found.kind.to_kind_name(), - self.text, - &arg.identifier.as_ref().into(), - )); - } - } - } - } - Ok(()) - } -} diff --git a/crates/analyzer/src/handlers/check_proto.rs b/crates/analyzer/src/handlers/check_proto.rs new file mode 100644 index 00000000..fe1383de --- /dev/null +++ b/crates/analyzer/src/handlers/check_proto.rs @@ -0,0 +1,84 @@ +use crate::analyzer_error::AnalyzerError; +use crate::symbol::{ProtoIncompatible, SymbolKind}; +use crate::symbol_table; +use veryl_parser::veryl_grammar_trait::*; +use veryl_parser::veryl_walker::{Handler, HandlerPoint}; +use veryl_parser::ParolError; + +#[derive(Default)] +pub struct CheckProto<'a> { + pub errors: Vec, + text: &'a str, + point: HandlerPoint, +} + +impl<'a> CheckProto<'a> { + pub fn new(text: &'a str) -> Self { + Self { + text, + ..Default::default() + } + } +} + +impl<'a> Handler for CheckProto<'a> { + fn set_point(&mut self, p: HandlerPoint) { + self.point = p; + } +} + +impl<'a> VerylGrammarTrait for CheckProto<'a> { + fn module_declaration(&mut self, arg: &ModuleDeclaration) -> Result<(), ParolError> { + if let HandlerPoint::Before = self.point { + if let Some(ref x) = arg.module_declaration_opt1 { + if let Ok(symbol) = symbol_table::resolve(x.scoped_identifier.as_ref()) { + if let SymbolKind::ProtoModule(proto) = symbol.found.kind { + if let Ok(module) = symbol_table::resolve(arg.identifier.as_ref()) { + if let SymbolKind::Module(module) = module.found.kind { + let errors = proto.check_compat(&module); + for error in errors { + let cause = match error { + ProtoIncompatible::MissingParam(x) => { + format!("parameter {x} is missing") + } + ProtoIncompatible::MissingPort(x) => { + format!("port {x} is missing") + } + ProtoIncompatible::UnnecessaryParam(x) => { + format!("parameter {x} is unnecessary") + } + ProtoIncompatible::UnnecessaryPort(x) => { + format!("port {x} is unnecessary") + } + ProtoIncompatible::IncompatibleParam(x) => { + format!("parameter {x} has incompatible type") + } + ProtoIncompatible::IncompatiblePort(x) => { + format!("port {x} has incompatible type") + } + }; + self.errors.push(AnalyzerError::incompat_proto( + &arg.identifier.identifier_token.to_string(), + &symbol.found.token.to_string(), + &cause, + self.text, + &arg.identifier.identifier_token.token.into(), + )); + } + } + } + } else { + self.errors.push(AnalyzerError::mismatch_type( + &symbol.found.token.to_string(), + "module prototype", + &symbol.found.kind.to_kind_name(), + self.text, + &x.scoped_identifier.identifier().token.into(), + )); + } + } + } + } + Ok(()) + } +} diff --git a/crates/analyzer/src/handlers/check_type.rs b/crates/analyzer/src/handlers/check_type.rs new file mode 100644 index 00000000..d06072bd --- /dev/null +++ b/crates/analyzer/src/handlers/check_type.rs @@ -0,0 +1,305 @@ +use crate::analyzer_error::AnalyzerError; +use crate::attribute::AllowItem; +use crate::attribute::Attribute as Attr; +use crate::attribute_table; +use crate::namespace_table; +use crate::symbol::{GenericBoundKind, Symbol, SymbolKind, TypeKind}; +use crate::symbol_path::GenericSymbolPath; +use crate::symbol_table; +use veryl_parser::resource_table; +use veryl_parser::veryl_grammar_trait::*; +use veryl_parser::veryl_walker::{Handler, HandlerPoint, VerylWalker}; +use veryl_parser::{ParolError, Stringifier}; + +#[derive(Default)] +pub struct CheckType<'a> { + pub errors: Vec, + text: &'a str, + point: HandlerPoint, + in_variable_type: bool, + in_modport: bool, +} + +impl<'a> CheckType<'a> { + pub fn new(text: &'a str) -> Self { + Self { + text, + ..Default::default() + } + } +} + +impl<'a> Handler for CheckType<'a> { + fn set_point(&mut self, p: HandlerPoint) { + self.point = p; + } +} + +fn is_variable_type(symbol: &Symbol) -> bool { + match &symbol.kind { + SymbolKind::Enum(_) + | SymbolKind::Union(_) + | SymbolKind::Struct(_) + | SymbolKind::TypeDef(_) + | SymbolKind::SystemVerilog => true, + SymbolKind::Parameter(x) => x.r#type.kind == TypeKind::Type, + SymbolKind::GenericParameter(x) => x.bound == GenericBoundKind::Type, + SymbolKind::GenericInstance(x) => { + let base = symbol_table::get(x.base).unwrap(); + is_variable_type(&base) + } + _ => false, + } +} + +impl<'a> VerylGrammarTrait for CheckType<'a> { + fn variable_type(&mut self, _arg: &VariableType) -> Result<(), ParolError> { + match self.point { + HandlerPoint::Before => self.in_variable_type = true, + HandlerPoint::After => self.in_variable_type = false, + } + Ok(()) + } + + fn port_declaration_item(&mut self, arg: &PortDeclarationItem) -> Result<(), ParolError> { + let is_modport = if let PortDeclarationItemGroup::PortTypeConcrete(x) = + &*arg.port_declaration_item_group + { + let x = x.port_type_concrete.as_ref(); + matches!(&*x.direction, Direction::Modport(_)) + } else { + false + }; + + match self.point { + HandlerPoint::Before => self.in_modport = is_modport, + HandlerPoint::After => self.in_modport = false, + } + Ok(()) + } + + fn scoped_identifier(&mut self, arg: &ScopedIdentifier) -> Result<(), ParolError> { + if let HandlerPoint::Before = self.point { + // Check variable type + if self.in_variable_type { + if let Ok(symbol) = symbol_table::resolve(arg) { + if self.in_modport { + if !matches!(symbol.found.kind, SymbolKind::Modport(_)) { + self.errors.push(AnalyzerError::mismatch_type( + &symbol.found.token.to_string(), + "modport", + &symbol.found.kind.to_kind_name(), + self.text, + &arg.identifier().token.into(), + )); + } + } else if !is_variable_type(&symbol.found) { + self.errors.push(AnalyzerError::mismatch_type( + &symbol.found.token.to_string(), + "enum or union or struct", + &symbol.found.kind.to_kind_name(), + self.text, + &arg.identifier().token.into(), + )); + } + } + } + + // Check generic argument type + let namespace = namespace_table::get(arg.identifier().token.id).unwrap(); + let path: GenericSymbolPath = arg.into(); + for i in 0..path.len() { + let base_path = path.base_path(i); + if let Ok(symbol) = symbol_table::resolve((&base_path, &namespace)) { + let params = symbol.found.generic_parameters(); + let args = &path.paths[i].arguments; + let defined_namespace = symbol.found.namespace; + + for (i, arg) in args.iter().enumerate() { + if let Some(param) = params.get(i) { + match ¶m.1.bound { + GenericBoundKind::Const => (), + GenericBoundKind::Type => { + let is_type = if arg.is_resolvable() { + if let Ok(symbol) = + symbol_table::resolve((&arg.generic_path(), &namespace)) + { + is_variable_type(&symbol.found) + } else { + false + } + } else { + false + }; + + if !is_type { + self.errors.push(AnalyzerError::mismatch_type( + &symbol.found.token.to_string(), + "enum or union or struct", + &symbol.found.kind.to_kind_name(), + self.text, + &arg.range, + )); + } + } + GenericBoundKind::Proto(proto) => { + let proto_match = if arg.is_resolvable() { + if let Ok(symbol) = + symbol_table::resolve((&arg.generic_path(), &namespace)) + { + if let Some(ref x) = symbol.found.kind.proto() { + let actual = symbol_table::resolve((x, &namespace)); + let required = symbol_table::resolve(( + proto, + &defined_namespace, + )); + if let (Ok(actual), Ok(required)) = + (actual, required) + { + actual.found.id == required.found.id + } else { + false + } + } else { + false + } + } else { + false + } + } else { + false + }; + + if !proto_match { + self.errors.push(AnalyzerError::mismatch_type( + &symbol.found.token.to_string(), + &format!("proto {proto}"), + &symbol.found.kind.to_kind_name(), + self.text, + &arg.range, + )); + } + } + } + } + } + } + } + } + Ok(()) + } + + fn inst_declaration(&mut self, arg: &InstDeclaration) -> Result<(), ParolError> { + if let HandlerPoint::Before = self.point { + let mut connected_params = Vec::new(); + if let Some(ref x) = arg.inst_declaration_opt0 { + if let Some(ref x) = x.inst_parameter.inst_parameter_opt { + let items: Vec = x.inst_parameter_list.as_ref().into(); + for item in items { + connected_params.push(item.identifier.identifier_token.token.text); + } + } + } + + let mut connected_ports = Vec::new(); + if let Some(ref x) = arg.inst_declaration_opt1 { + if let Some(ref x) = x.inst_declaration_opt2 { + let items: Vec = x.inst_port_list.as_ref().into(); + for item in items { + connected_ports.push(item.identifier.identifier_token.token.text); + } + } + } + + if let Ok(symbol) = symbol_table::resolve(arg.scoped_identifier.as_ref()) { + let mut stringifier = Stringifier::new(); + stringifier.scoped_identifier(&arg.scoped_identifier); + let name = stringifier.as_str(); + + let mut params = vec![]; + let mut ports = vec![]; + let mut check_port_connection = false; + match symbol.found.kind { + SymbolKind::Module(ref x) => { + params.append(&mut x.parameters.clone()); + ports.append(&mut x.ports.clone()); + check_port_connection = true; + } + SymbolKind::Interface(_) => (), + SymbolKind::SystemVerilog => (), + SymbolKind::GenericParameter(ref x) => { + if let GenericBoundKind::Proto(ref x) = x.bound { + if let Ok(symbol) = symbol_table::resolve((x, &symbol.found.namespace)) + { + if let SymbolKind::ProtoModule(x) = symbol.found.kind { + params.append(&mut x.parameters.clone()); + ports.append(&mut x.ports.clone()); + check_port_connection = true; + } else { + self.errors.push(AnalyzerError::mismatch_type( + name, + "module or interface", + &symbol.found.kind.to_kind_name(), + self.text, + &arg.identifier.as_ref().into(), + )); + } + } + } + } + _ => { + self.errors.push(AnalyzerError::mismatch_type( + name, + "module or interface", + &symbol.found.kind.to_kind_name(), + self.text, + &arg.identifier.as_ref().into(), + )); + } + } + + if check_port_connection { + for port in &ports { + if !connected_ports.contains(&port.name) + && !attribute_table::contains( + &arg.inst.inst_token.token, + Attr::Allow(AllowItem::MissingPort), + ) + { + let port = resource_table::get_str_value(port.name).unwrap(); + self.errors.push(AnalyzerError::missing_port( + name, + &port, + self.text, + &arg.identifier.as_ref().into(), + )); + } + } + for param in &connected_params { + if !params.iter().any(|x| &x.name == param) { + let param = resource_table::get_str_value(*param).unwrap(); + self.errors.push(AnalyzerError::unknown_param( + name, + ¶m, + self.text, + &arg.identifier.as_ref().into(), + )); + } + } + for port in &connected_ports { + if !ports.iter().any(|x| &x.name == port) { + let port = resource_table::get_str_value(*port).unwrap(); + self.errors.push(AnalyzerError::unknown_port( + name, + &port, + self.text, + &arg.identifier.as_ref().into(), + )); + } + } + } + } + } + Ok(()) + } +} diff --git a/crates/analyzer/src/handlers/create_reference.rs b/crates/analyzer/src/handlers/create_reference.rs index 30335686..ebc4d896 100644 --- a/crates/analyzer/src/handlers/create_reference.rs +++ b/crates/analyzer/src/handlers/create_reference.rs @@ -69,7 +69,7 @@ impl<'a> CreateReference<'a> { let params = symbol.found.generic_parameters(); let n_args = path.paths[i].arguments.len(); let match_artiy = if params.len() > n_args { - params[n_args].1.is_some() + params[n_args].1.default_value.is_some() } else { params.len() == n_args }; @@ -89,7 +89,8 @@ impl<'a> CreateReference<'a> { for param in params.iter().skip(n_args) { // apply default value - path.arguments.push(param.1.as_ref().unwrap().clone()); + path.arguments + .push(param.1.default_value.as_ref().unwrap().clone()); } if let Some((token, new_symbol)) = path.get_generic_instance(&symbol.found) { diff --git a/crates/analyzer/src/handlers/create_symbol_table.rs b/crates/analyzer/src/handlers/create_symbol_table.rs index f56d4ac2..e2d8027b 100644 --- a/crates/analyzer/src/handlers/create_symbol_table.rs +++ b/crates/analyzer/src/handlers/create_symbol_table.rs @@ -12,11 +12,12 @@ use crate::symbol::Direction as SymDirection; use crate::symbol::Type as SymType; use crate::symbol::{ ConnectTarget, DocComment, EnumMemberProperty, EnumMemberValue, EnumProperty, FunctionProperty, - GenericParameterProperty, InstanceProperty, InterfaceProperty, ModportFunctionMemberProperty, - ModportProperty, ModportVariableMemberProperty, ModuleProperty, PackageProperty, Parameter, - ParameterProperty, ParameterScope, ParameterValue, Port, PortProperty, StructMemberProperty, - StructProperty, Symbol, SymbolId, SymbolKind, TestProperty, TestType, TypeDefProperty, - TypeKind, UnionMemberProperty, UnionProperty, VariableAffiniation, VariableProperty, + GenericBoundKind, GenericParameterProperty, InstanceProperty, InterfaceProperty, + ModportFunctionMemberProperty, ModportProperty, ModportVariableMemberProperty, ModuleProperty, + PackageProperty, Parameter, ParameterProperty, ParameterScope, ParameterValue, Port, + PortProperty, ProtoModuleProperty, StructMemberProperty, StructProperty, Symbol, SymbolId, + SymbolKind, TestProperty, TestType, TypeDefProperty, TypeKind, UnionMemberProperty, + UnionProperty, VariableAffiniation, VariableProperty, }; use crate::symbol_path::{GenericSymbolPath, SymbolPath}; use crate::symbol_table; @@ -62,6 +63,7 @@ pub struct CreateSymbolTable<'a> { modport_member_ids: Vec, function_ids: HashMap, exist_clock_without_domain: bool, + in_proto: bool, } #[derive(Clone)] @@ -920,8 +922,19 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { None }; + let bound = match arg.generic_bound.as_ref() { + GenericBound::Const(_) => GenericBoundKind::Const, + GenericBound::Type(_) => GenericBoundKind::Type, + GenericBound::ScopedIdentifier(x) => { + GenericBoundKind::Proto(x.scoped_identifier.as_ref().into()) + } + }; + if !self.needs_default_generic_argument || default_value.is_some() { - let property = GenericParameterProperty { default_value }; + let property = GenericParameterProperty { + bound, + default_value, + }; let kind = SymbolKind::GenericParameter(property); if let Some(id) = self.insert_symbol(&arg.identifier.identifier_token.token, kind, false) @@ -967,6 +980,7 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { prefix, suffix, clock_domain, + is_proto: self.in_proto, } } PortDeclarationItemGroup::PortTypeAbstract(x) => { @@ -985,6 +999,7 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { prefix: None, suffix: None, clock_domain, + is_proto: self.in_proto, } } }; @@ -1092,9 +1107,14 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { self.defualt_reset_candidates.clear(); let range = TokenRange::new(&arg.module.module_token, &arg.r_brace.r_brace_token); + let proto = arg + .module_declaration_opt1 + .as_ref() + .map(|x| x.scoped_identifier.as_ref().into()); let property = ModuleProperty { range, + proto, generic_parameters, generic_references, parameters, @@ -1332,6 +1352,43 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { Ok(()) } + fn proto_module_declaration(&mut self, arg: &ProtoModuleDeclaration) -> Result<(), ParolError> { + let name = arg.identifier.identifier_token.token.text; + match self.point { + HandlerPoint::Before => { + self.namespace.push(name); + self.parameters.push(Vec::new()); + self.ports.push(Vec::new()); + self.affiniation.push(VariableAffiniation::Module); + self.in_proto = true; + } + HandlerPoint::After => { + self.namespace.pop(); + self.affiniation.pop(); + self.in_proto = false; + + let parameters: Vec<_> = self.parameters.pop().unwrap(); + let ports: Vec<_> = self.ports.pop().unwrap(); + + let range = + TokenRange::new(&arg.module.module_token, &arg.semicolon.semicolon_token); + + let property = ProtoModuleProperty { + range, + parameters, + ports, + }; + let public = arg.proto_module_declaration_opt.is_some(); + self.insert_symbol( + &arg.identifier.identifier_token.token, + SymbolKind::ProtoModule(property), + public, + ); + } + } + Ok(()) + } + fn embed_declaration(&mut self, arg: &EmbedDeclaration) -> Result<(), ParolError> { if let HandlerPoint::Before = self.point { let way = arg.identifier.identifier_token.to_string(); diff --git a/crates/analyzer/src/namespace.rs b/crates/analyzer/src/namespace.rs index 76f182af..e2d027f5 100644 --- a/crates/analyzer/src/namespace.rs +++ b/crates/analyzer/src/namespace.rs @@ -4,7 +4,7 @@ use std::collections::HashMap; use std::fmt; use veryl_parser::resource_table::StrId; -#[derive(Debug, Clone, PartialEq)] +#[derive(Debug, Clone, PartialEq, Eq)] pub struct Namespace { pub paths: Vec, } diff --git a/crates/analyzer/src/symbol.rs b/crates/analyzer/src/symbol.rs index 7cc55440..bbb354ca 100644 --- a/crates/analyzer/src/symbol.rs +++ b/crates/analyzer/src/symbol.rs @@ -212,17 +212,17 @@ impl Symbol { } for param in generic_parameters.iter().skip(arguments.len()) { - ret.insert(param.0, param.1.as_ref().unwrap().clone()); + ret.insert(param.0, param.1.default_value.as_ref().unwrap().clone()); } ret } - pub fn generic_parameters(&self) -> Vec<(StrId, Option)> { - fn get_generic_parameter(id: SymbolId) -> (StrId, Option) { + pub fn generic_parameters(&self) -> Vec<(StrId, GenericParameterProperty)> { + fn get_generic_parameter(id: SymbolId) -> (StrId, GenericParameterProperty) { let symbol = symbol_table::get(id).unwrap(); if let SymbolKind::GenericParameter(x) = symbol.kind { - (symbol.token.text, x.default_value) + (symbol.token.text, x) } else { unreachable!() } @@ -281,6 +281,7 @@ pub enum SymbolKind { Port(PortProperty), Variable(VariableProperty), Module(ModuleProperty), + ProtoModule(ProtoModuleProperty), Interface(InterfaceProperty), Function(FunctionProperty), Parameter(ParameterProperty), @@ -314,6 +315,7 @@ impl SymbolKind { SymbolKind::Port(_) => "port".to_string(), SymbolKind::Variable(_) => "variable".to_string(), SymbolKind::Module(_) => "module".to_string(), + SymbolKind::ProtoModule(_) => "proto module".to_string(), SymbolKind::Interface(_) => "interface".to_string(), SymbolKind::Function(_) => "function".to_string(), SymbolKind::Parameter(_) => "parameter".to_string(), @@ -381,6 +383,17 @@ impl SymbolKind { _ => false, } } + + pub fn proto(&self) -> Option { + match self { + SymbolKind::Module(x) => x.proto.clone(), + SymbolKind::GenericParameter(x) => match x.bound { + GenericBoundKind::Proto(ref x) => Some(x.clone()), + _ => None, + }, + _ => None, + } + } } impl fmt::Display for SymbolKind { @@ -404,6 +417,13 @@ impl fmt::Display for SymbolKind { x.ports.len() ) } + SymbolKind::ProtoModule(x) => { + format!( + "proto module ({} params, {} ports)", + x.parameters.len(), + x.ports.len() + ) + } SymbolKind::Interface(x) => { format!( "interface ({} generic, {} params)", @@ -665,20 +685,19 @@ impl From<&syntax_tree::ScalarType> for Type { } } match &*value.scalar_type_group { - syntax_tree::ScalarTypeGroup::VariableType(x) => { - let x = &x.variable_type; - let kind = match &*x.variable_type_group { - syntax_tree::VariableTypeGroup::Clock(_) => TypeKind::Clock, - syntax_tree::VariableTypeGroup::ClockPosedge(_) => TypeKind::ClockPosedge, - syntax_tree::VariableTypeGroup::ClockNegedge(_) => TypeKind::ClockNegedge, - syntax_tree::VariableTypeGroup::Reset(_) => TypeKind::Reset, - syntax_tree::VariableTypeGroup::ResetAsyncHigh(_) => TypeKind::ResetAsyncHigh, - syntax_tree::VariableTypeGroup::ResetAsyncLow(_) => TypeKind::ResetAsyncLow, - syntax_tree::VariableTypeGroup::ResetSyncHigh(_) => TypeKind::ResetSyncHigh, - syntax_tree::VariableTypeGroup::ResetSyncLow(_) => TypeKind::ResetSyncLow, - syntax_tree::VariableTypeGroup::Logic(_) => TypeKind::Logic, - syntax_tree::VariableTypeGroup::Bit(_) => TypeKind::Bit, - syntax_tree::VariableTypeGroup::ScopedIdentifier(x) => { + syntax_tree::ScalarTypeGroup::VariableTypeScalarTypeOpt(x) => { + let kind = match x.variable_type.as_ref() { + syntax_tree::VariableType::Clock(_) => TypeKind::Clock, + syntax_tree::VariableType::ClockPosedge(_) => TypeKind::ClockPosedge, + syntax_tree::VariableType::ClockNegedge(_) => TypeKind::ClockNegedge, + syntax_tree::VariableType::Reset(_) => TypeKind::Reset, + syntax_tree::VariableType::ResetAsyncHigh(_) => TypeKind::ResetAsyncHigh, + syntax_tree::VariableType::ResetAsyncLow(_) => TypeKind::ResetAsyncLow, + syntax_tree::VariableType::ResetSyncHigh(_) => TypeKind::ResetSyncHigh, + syntax_tree::VariableType::ResetSyncLow(_) => TypeKind::ResetSyncLow, + syntax_tree::VariableType::Logic(_) => TypeKind::Logic, + syntax_tree::VariableType::Bit(_) => TypeKind::Bit, + syntax_tree::VariableType::ScopedIdentifier(x) => { let x = &x.scoped_identifier; let mut name = Vec::new(); match &*x.scoped_identifier_group { @@ -698,7 +717,7 @@ impl From<&syntax_tree::ScalarType> for Type { } }; let mut width = Vec::new(); - if let Some(ref x) = x.variable_type_opt { + if let Some(ref x) = x.scalar_type_opt { let x = &x.width; width.push(*x.expression.clone()); for x in &x.width_list { @@ -810,6 +829,7 @@ pub struct PortProperty { pub prefix: Option, pub suffix: Option, pub clock_domain: ClockDomain, + pub is_proto: bool, } #[derive(Debug, Clone)] @@ -881,6 +901,7 @@ impl Parameter { #[derive(Debug, Clone)] pub struct ModuleProperty { pub range: TokenRange, + pub proto: Option, pub generic_parameters: Vec, pub generic_references: Vec, pub parameters: Vec, @@ -889,6 +910,72 @@ pub struct ModuleProperty { pub default_reset: Option, } +#[derive(Debug, Clone)] +pub struct ProtoModuleProperty { + pub range: TokenRange, + pub parameters: Vec, + pub ports: Vec, +} + +pub enum ProtoIncompatible { + MissingParam(StrId), + MissingPort(StrId), + UnnecessaryParam(StrId), + UnnecessaryPort(StrId), + IncompatibleParam(StrId), + IncompatiblePort(StrId), +} + +impl ProtoModuleProperty { + pub fn check_compat(&self, p: &ModuleProperty) -> Vec { + let mut ret = Vec::new(); + + let actual_params: HashMap<_, _> = p + .parameters + .iter() + .map(|x| (x.name, x.property())) + .collect(); + let actual_ports: HashMap<_, _> = p.ports.iter().map(|x| (x.name, x.property())).collect(); + let mut proto_params: HashMap<_, _> = self + .parameters + .iter() + .map(|x| (x.name, x.property())) + .collect(); + let mut proto_ports: HashMap<_, _> = + self.ports.iter().map(|x| (x.name, x.property())).collect(); + + for (name, actual_param) in actual_params { + if let Some(proto_param) = proto_params.remove(&name) { + if proto_param.r#type.to_string() != actual_param.r#type.to_string() { + ret.push(ProtoIncompatible::IncompatibleParam(name)); + } + } else { + ret.push(ProtoIncompatible::UnnecessaryParam(name)); + } + } + for (name, _) in proto_params { + ret.push(ProtoIncompatible::MissingParam(name)); + } + + for (name, actual_port) in actual_ports { + if let Some(proto_port) = proto_ports.remove(&name) { + if proto_port.r#type.map(|x| x.to_string()) + != actual_port.r#type.map(|x| x.to_string()) + { + ret.push(ProtoIncompatible::IncompatiblePort(name)); + } + } else { + ret.push(ProtoIncompatible::UnnecessaryPort(name)); + } + } + for (name, _) in proto_ports { + ret.push(ProtoIncompatible::MissingPort(name)); + } + + ret + } +} + #[derive(Debug, Clone)] pub struct InterfaceProperty { pub range: TokenRange, @@ -1044,8 +1131,27 @@ pub struct ModportFunctionMemberProperty { pub function: SymbolId, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum GenericBoundKind { + Const, + Type, + Proto(SymbolPath), +} + +impl fmt::Display for GenericBoundKind { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let text = match self { + GenericBoundKind::Const => "const".to_string(), + GenericBoundKind::Type => "type".to_string(), + GenericBoundKind::Proto(x) => x.to_string(), + }; + text.fmt(f) + } +} + #[derive(Debug, Clone)] pub struct GenericParameterProperty { + pub bound: GenericBoundKind, pub default_value: Option, } diff --git a/crates/analyzer/src/symbol_path.rs b/crates/analyzer/src/symbol_path.rs index b0c56381..3399e5e5 100644 --- a/crates/analyzer/src/symbol_path.rs +++ b/crates/analyzer/src/symbol_path.rs @@ -8,7 +8,7 @@ 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)] +#[derive(Debug, Default, Clone, PartialEq, Eq)] pub struct SymbolPath(pub Vec); impl SymbolPath { @@ -109,7 +109,7 @@ impl From<&syntax_tree::ExpressionIdentifier> for SymbolPath { } } -#[derive(Clone, Default, Debug)] +#[derive(Clone, Default, Debug, PartialEq, Eq)] pub struct SymbolPathNamespace(pub SymbolPath, pub Namespace); impl From<&Token> for SymbolPathNamespace { @@ -302,6 +302,11 @@ impl GenericSymbolPath { SymbolPath::new(&path) } + pub fn generic_path(&self) -> SymbolPath { + let path: Vec<_> = self.paths.iter().map(|x| x.base()).collect(); + SymbolPath::new(&path) + } + pub fn is_resolvable(&self) -> bool { self.kind == GenericSymbolPathKind::Identifier } diff --git a/crates/analyzer/src/symbol_table.rs b/crates/analyzer/src/symbol_table.rs index 85fb9f7f..975cbe8a 100644 --- a/crates/analyzer/src/symbol_table.rs +++ b/crates/analyzer/src/symbol_table.rs @@ -253,6 +253,7 @@ impl SymbolTable { } // don't trace inner item SymbolKind::Function(_) + | SymbolKind::ProtoModule(_) | SymbolKind::Struct(_) | SymbolKind::Union(_) | SymbolKind::Modport(_) diff --git a/crates/analyzer/src/tests.rs b/crates/analyzer/src/tests.rs index 69a714f7..fa632c35 100644 --- a/crates/analyzer/src/tests.rs +++ b/crates/analyzer/src/tests.rs @@ -792,22 +792,22 @@ fn mismatch_function_arity() { fn missing_default_generic_argument() { let code = r#" module ModuleA { - function FuncA:: () -> logic {} + function FuncA:: () -> logic {} let _a: logic = FuncA::<1>(); - function FuncB:: () -> logic {} + function FuncB:: () -> logic {} let _b: logic = FuncB::<1, 2, 3>(); - function FuncC:: () -> logic {} + function FuncC:: () -> logic {} let _c: logic = FuncC::<>(); - function FuncD:: () -> logic {} + function FuncD:: () -> logic {} let _d: logic = FuncD::<>(); - function FuncE:: () -> logic {} + function FuncE:: () -> logic {} let _e: logic = FuncE::<1>(); - function FuncF:: () -> logic {} + function FuncF:: () -> logic {} let _f: logic = FuncF::<1, 2>(); } "#; @@ -817,7 +817,7 @@ fn missing_default_generic_argument() { let code = r#" module ModuleB { - function FuncA:: () -> logic {} + function FuncA:: () -> logic {} let _a: logic = FuncA::<1, 2, 3> (); } "#; @@ -830,7 +830,7 @@ fn missing_default_generic_argument() { let code = r#" module ModuleC { - function FuncA:: () -> logic {} + function FuncA:: () -> logic {} let _a: logic = FuncA::<1, 2, 3>(); } "#; @@ -846,7 +846,7 @@ fn missing_default_generic_argument() { fn mismatch_generics_arity() { let code = r#" module ModuleA { - function FuncA:: ( + function FuncA:: ( a: input logic, ) -> logic {} @@ -862,7 +862,7 @@ fn mismatch_generics_arity() { let code = r#" module ModuleB { - function FuncA:: ( + function FuncA:: ( a: input logic, ) -> logic {} @@ -877,7 +877,7 @@ fn mismatch_generics_arity() { )); let code = r#" - package PackageC:: { + package PackageC:: { struct StructC { c: logic, } @@ -893,11 +893,11 @@ fn mismatch_generics_arity() { let code = r#" package PackageD { - function FuncD:: -> logic { + function FuncD:: -> logic { return 0; } } - module SubD:: { + module SubD:: { let _d: logic = PackageD::FuncD::(); } module TopD { @@ -993,7 +993,7 @@ fn mismatch_type() { let code = r#" module ModuleG { - function FuncG:: -> T { + function FuncG:: -> T { var g: T; g = 0; return g; @@ -1008,7 +1008,7 @@ fn mismatch_type() { let code = r#" module ModuleH { - function FuncH:: -> T { + function FuncH:: -> T { var h: T; h = 0; return h; @@ -1021,6 +1021,51 @@ fn mismatch_type() { let errors = analyze(code); assert!(errors.is_empty()); + + let code = r#" + interface InterfaceI {} + + module ModuleI ( + a: modport InterfaceI, + ) {} + "#; + + let errors = analyze(code); + assert!(matches!(errors[0], AnalyzerError::MismatchType { .. })); + + let code = r#" + module ModuleJ { + function FuncJ:: -> T { + var g: T; + g = 0; + return g; + } + + local X: u32 = 1; + let _g: logic = FuncJ::(); + } + "#; + + let errors = analyze(code); + assert!(matches!(errors[0], AnalyzerError::MismatchType { .. })); + + let code = r#" + proto module ProtoK0; + proto module ProtoK1; + + module ModuleK0:: { + inst u: T; + } + + module ModuleK1 for ProtoK1 {} + + module ModuleK2 { + inst u: ModuleK0::(); + } + "#; + + let errors = analyze(code); + assert!(matches!(errors[0], AnalyzerError::MismatchType { .. })); } #[test] diff --git a/crates/emitter/src/aligner.rs b/crates/emitter/src/aligner.rs index e57bf699..3ff3d915 100644 --- a/crates/emitter/src/aligner.rs +++ b/crates/emitter/src/aligner.rs @@ -538,34 +538,6 @@ impl VerylWalker for Aligner { self.r_bracket(&arg.r_bracket); } - /// Semantic action for non-terminal 'VariableType' - fn variable_type(&mut self, arg: &VariableType) { - match &*arg.variable_type_group { - VariableTypeGroup::Clock(x) => self.clock(&x.clock), - VariableTypeGroup::ClockPosedge(x) => self.clock_posedge(&x.clock_posedge), - VariableTypeGroup::ClockNegedge(x) => self.clock_negedge(&x.clock_negedge), - VariableTypeGroup::Reset(x) => self.reset(&x.reset), - VariableTypeGroup::ResetAsyncHigh(x) => self.reset_async_high(&x.reset_async_high), - VariableTypeGroup::ResetAsyncLow(x) => self.reset_async_low(&x.reset_async_low), - VariableTypeGroup::ResetSyncHigh(x) => self.reset_sync_high(&x.reset_sync_high), - VariableTypeGroup::ResetSyncLow(x) => self.reset_sync_low(&x.reset_sync_low), - VariableTypeGroup::Logic(x) => self.logic(&x.logic), - VariableTypeGroup::Bit(x) => self.bit(&x.bit), - VariableTypeGroup::ScopedIdentifier(x) => self.scoped_identifier(&x.scoped_identifier), - }; - if !self.in_type_expression { - self.aligns[align_kind::TYPE].finish_item(); - self.aligns[align_kind::WIDTH].start_item(); - } - if let Some(ref x) = arg.variable_type_opt { - self.space(1); - self.width(&x.width); - } else if !self.in_type_expression { - let loc = self.aligns[align_kind::TYPE].last_location; - self.aligns[align_kind::WIDTH].dummy_location(loc.unwrap()); - } - } - /// Semantic action for non-terminal 'ScalarType' fn scalar_type(&mut self, arg: &ScalarType) { if !self.in_type_expression { @@ -578,7 +550,20 @@ impl VerylWalker for Aligner { self.space(1); } match &*arg.scalar_type_group { - ScalarTypeGroup::VariableType(x) => self.variable_type(&x.variable_type), + ScalarTypeGroup::VariableTypeScalarTypeOpt(x) => { + self.variable_type(&x.variable_type); + if !self.in_type_expression { + self.aligns[align_kind::TYPE].finish_item(); + self.aligns[align_kind::WIDTH].start_item(); + } + if let Some(ref x) = x.scalar_type_opt { + self.space(1); + self.width(&x.width); + } else if !self.in_type_expression { + let loc = self.aligns[align_kind::TYPE].last_location; + self.aligns[align_kind::WIDTH].dummy_location(loc.unwrap()); + } + } ScalarTypeGroup::FixedType(x) => { self.fixed_type(&x.fixed_type); if !self.in_type_expression { diff --git a/crates/emitter/src/emitter.rs b/crates/emitter/src/emitter.rs index a5032742..f99724aa 100644 --- a/crates/emitter/src/emitter.rs +++ b/crates/emitter/src/emitter.rs @@ -949,7 +949,7 @@ impl VerylWalker for Emitter { for param in params.iter().skip(n_args) { path.paths[i] .arguments - .push(param.1.as_ref().unwrap().clone()); + .push(param.1.default_value.as_ref().unwrap().clone()); } } } @@ -1498,31 +1498,6 @@ impl VerylWalker for Emitter { } } - /// Semantic action for non-terminal 'VariableType' - fn variable_type(&mut self, arg: &VariableType) { - match &*arg.variable_type_group { - VariableTypeGroup::Clock(x) => self.clock(&x.clock), - VariableTypeGroup::ClockPosedge(x) => self.clock_posedge(&x.clock_posedge), - VariableTypeGroup::ClockNegedge(x) => self.clock_negedge(&x.clock_negedge), - VariableTypeGroup::Reset(x) => self.reset(&x.reset), - VariableTypeGroup::ResetAsyncHigh(x) => self.reset_async_high(&x.reset_async_high), - VariableTypeGroup::ResetAsyncLow(x) => self.reset_async_low(&x.reset_async_low), - VariableTypeGroup::ResetSyncHigh(x) => self.reset_sync_high(&x.reset_sync_high), - VariableTypeGroup::ResetSyncLow(x) => self.reset_sync_low(&x.reset_sync_low), - VariableTypeGroup::Logic(x) => self.logic(&x.logic), - VariableTypeGroup::Bit(x) => self.bit(&x.bit), - VariableTypeGroup::ScopedIdentifier(x) => self.scoped_identifier(&x.scoped_identifier), - }; - if self.signed { - self.space(1); - self.str("signed"); - } - if let Some(ref x) = arg.variable_type_opt { - self.space(1); - self.width(&x.width); - } - } - /// Semantic action for non-terminal 'TypeModifier' fn type_modifier(&mut self, arg: &TypeModifier) { match arg { @@ -1540,7 +1515,17 @@ impl VerylWalker for Emitter { self.type_modifier(&x.type_modifier); } match &*arg.scalar_type_group { - ScalarTypeGroup::VariableType(x) => self.variable_type(&x.variable_type), + ScalarTypeGroup::VariableTypeScalarTypeOpt(x) => { + self.variable_type(&x.variable_type); + if self.signed { + self.space(1); + self.str("signed"); + } + if let Some(ref x) = x.scalar_type_opt { + self.space(1); + self.width(&x.width); + } + } ScalarTypeGroup::FixedType(x) => self.fixed_type(&x.fixed_type), } self.signed = false; @@ -3017,11 +3002,11 @@ impl VerylWalker for Emitter { if !file_scope_import.is_empty() { self.newline_pop(); } - if let Some(ref x) = arg.module_declaration_opt1 { + if let Some(ref x) = arg.module_declaration_opt2 { self.space(1); self.with_parameter(&x.with_parameter); } - if let Some(ref x) = arg.module_declaration_opt2 { + if let Some(ref x) = arg.module_declaration_opt3 { self.space(1); self.port_declaration(&x.port_declaration); } @@ -3501,6 +3486,8 @@ impl VerylWalker for Emitter { DescriptionItem::PackageDeclaration(x) => { self.package_declaration(&x.package_declaration) } + // proto is not emitted at SystemVerilog + DescriptionItem::ProtoModuleDeclaration(_) => (), // file scope import is not emitted at SystemVerilog DescriptionItem::ImportDeclaration(_) => (), DescriptionItem::EmbedDeclaration(x) => self.embed_declaration(&x.embed_declaration), @@ -3668,7 +3655,7 @@ pub fn symbol_string(token: &VerylToken, symbol: &Symbol, context: &SymbolContex } ret.push_str(&symbol.token.to_string()); } - SymbolKind::GenericParameter(_) => (), + SymbolKind::GenericParameter(_) | SymbolKind::ProtoModule(_) => (), SymbolKind::Port(x) => { if let Some(ref x) = x.prefix { ret.push_str(x); diff --git a/crates/formatter/src/aligner.rs b/crates/formatter/src/aligner.rs index 85a02010..3a09f305 100644 --- a/crates/formatter/src/aligner.rs +++ b/crates/formatter/src/aligner.rs @@ -431,34 +431,6 @@ impl VerylWalker for Aligner { self.r_bracket(&arg.r_bracket); } - /// Semantic action for non-terminal 'VariableType' - fn variable_type(&mut self, arg: &VariableType) { - match &*arg.variable_type_group { - VariableTypeGroup::Clock(x) => self.clock(&x.clock), - VariableTypeGroup::ClockPosedge(x) => self.clock_posedge(&x.clock_posedge), - VariableTypeGroup::ClockNegedge(x) => self.clock_negedge(&x.clock_negedge), - VariableTypeGroup::Reset(x) => self.reset(&x.reset), - VariableTypeGroup::ResetAsyncHigh(x) => self.reset_async_high(&x.reset_async_high), - VariableTypeGroup::ResetAsyncLow(x) => self.reset_async_low(&x.reset_async_low), - VariableTypeGroup::ResetSyncHigh(x) => self.reset_sync_high(&x.reset_sync_high), - VariableTypeGroup::ResetSyncLow(x) => self.reset_sync_low(&x.reset_sync_low), - VariableTypeGroup::Logic(x) => self.logic(&x.logic), - VariableTypeGroup::Bit(x) => self.bit(&x.bit), - VariableTypeGroup::ScopedIdentifier(x) => self.scoped_identifier(&x.scoped_identifier), - }; - if !self.in_type_expression { - self.aligns[align_kind::TYPE].finish_item(); - self.aligns[align_kind::WIDTH].start_item(); - } - if let Some(ref x) = arg.variable_type_opt { - self.width(&x.width); - } else if !self.in_type_expression { - let loc = self.aligns[align_kind::TYPE].last_location; - let loc = loc.unwrap(); - self.aligns[align_kind::WIDTH].dummy_location(loc); - } - } - /// Semantic action for non-terminal 'ScalarType' fn scalar_type(&mut self, arg: &ScalarType) { if !self.in_type_expression { @@ -469,7 +441,20 @@ impl VerylWalker for Aligner { self.space(1); } match &*arg.scalar_type_group { - ScalarTypeGroup::VariableType(x) => self.variable_type(&x.variable_type), + ScalarTypeGroup::VariableTypeScalarTypeOpt(x) => { + self.variable_type(&x.variable_type); + if !self.in_type_expression { + self.aligns[align_kind::TYPE].finish_item(); + self.aligns[align_kind::WIDTH].start_item(); + } + if let Some(ref x) = x.scalar_type_opt { + self.width(&x.width); + } else if !self.in_type_expression { + let loc = self.aligns[align_kind::TYPE].last_location; + let loc = loc.unwrap(); + self.aligns[align_kind::WIDTH].dummy_location(loc); + } + } ScalarTypeGroup::FixedType(x) => { self.fixed_type(&x.fixed_type); if !self.in_type_expression { diff --git a/crates/formatter/src/formatter.rs b/crates/formatter/src/formatter.rs index 184a7d24..a16c958f 100644 --- a/crates/formatter/src/formatter.rs +++ b/crates/formatter/src/formatter.rs @@ -606,7 +606,12 @@ impl VerylWalker for Formatter { self.space(1); } match &*arg.scalar_type_group { - ScalarTypeGroup::VariableType(x) => self.variable_type(&x.variable_type), + ScalarTypeGroup::VariableTypeScalarTypeOpt(x) => { + self.variable_type(&x.variable_type); + if let Some(ref x) = x.scalar_type_opt { + self.width(&x.width); + } + } ScalarTypeGroup::FixedType(x) => self.fixed_type(&x.fixed_type), }; } @@ -1460,6 +1465,9 @@ impl VerylWalker for Formatter { /// Semantic action for non-terminal 'WithGenericParameterItem' fn with_generic_parameter_item(&mut self, arg: &WithGenericParameterItem) { self.identifier(&arg.identifier); + self.colon(&arg.colon); + self.space(1); + self.generic_bound(&arg.generic_bound); if let Some(ref x) = arg.with_generic_parameter_item_opt { self.space(1); self.equ(&x.equ); @@ -1657,10 +1665,16 @@ impl VerylWalker for Formatter { } self.space(1); if let Some(ref x) = arg.module_declaration_opt1 { - self.with_parameter(&x.with_parameter); + self.r#for(&x.r#for); + self.space(1); + self.scoped_identifier(&x.scoped_identifier); self.space(1); } if let Some(ref x) = arg.module_declaration_opt2 { + self.with_parameter(&x.with_parameter); + self.space(1); + } + if let Some(ref x) = arg.module_declaration_opt3 { self.port_declaration(&x.port_declaration); self.space(1); } @@ -1934,6 +1948,28 @@ impl VerylWalker for Formatter { } } + /// Semantic action for non-terminal 'ProtoModuleDeclaration' + fn proto_module_declaration(&mut self, arg: &ProtoModuleDeclaration) { + if let Some(ref x) = arg.proto_module_declaration_opt { + self.r#pub(&x.r#pub); + self.space(1); + } + self.proto(&arg.proto); + self.space(1); + self.module(&arg.module); + self.space(1); + self.identifier(&arg.identifier); + if let Some(ref x) = arg.proto_module_declaration_opt0 { + self.space(1); + self.with_parameter(&x.with_parameter); + } + if let Some(ref x) = arg.proto_module_declaration_opt1 { + self.space(1); + self.port_declaration(&x.port_declaration); + } + self.semicolon(&arg.semicolon); + } + /// Semantic action for non-terminal 'EmbedDeclaration' fn embed_declaration(&mut self, arg: &EmbedDeclaration) { self.embed(&arg.embed); diff --git a/crates/languageserver/src/keyword.rs b/crates/languageserver/src/keyword.rs index c19b1b02..258cc077 100644 --- a/crates/languageserver/src/keyword.rs +++ b/crates/languageserver/src/keyword.rs @@ -8,6 +8,7 @@ pub const KEYWORDS: &[&str] = &[ "clock", "clock_posedge", "clock_negedge", + "const", "default", "else", "embed", @@ -42,6 +43,7 @@ pub const KEYWORDS: &[&str] = &[ "outside", "package", "param", + "proto", "pub", "ref", "repeat", diff --git a/crates/languageserver/src/server.rs b/crates/languageserver/src/server.rs index 5cc4c5f3..51ade823 100644 --- a/crates/languageserver/src/server.rs +++ b/crates/languageserver/src/server.rs @@ -313,6 +313,7 @@ impl Server { VerylSymbolKind::Port(_) => SymbolKind::VARIABLE, VerylSymbolKind::Variable(_) => SymbolKind::VARIABLE, VerylSymbolKind::Module(_) => SymbolKind::MODULE, + VerylSymbolKind::ProtoModule(_) => SymbolKind::MODULE, VerylSymbolKind::Interface(_) => SymbolKind::INTERFACE, VerylSymbolKind::Function(_) => SymbolKind::FUNCTION, VerylSymbolKind::Parameter(_) => SymbolKind::CONSTANT, diff --git a/crates/metadata/std b/crates/metadata/std index b0e9a9af..5e3caabe 160000 --- a/crates/metadata/std +++ b/crates/metadata/std @@ -1 +1 @@ -Subproject commit b0e9a9af6d4a412881a123d73eb96940f5b69e3d +Subproject commit 5e3caabe7c8d4fafa6f6fa09786103f201a0250e diff --git a/crates/parser/src/generated/veryl-exp.par b/crates/parser/src/generated/veryl-exp.par index 5fc4487f..0190f68f 100644 --- a/crates/parser/src/generated/veryl-exp.par +++ b/crates/parser/src/generated/veryl-exp.par @@ -65,926 +65,944 @@ /* 50 */ ClockTerm: /(?-u:\b)clock(?-u:\b)/ : Token; /* 51 */ ClockPosedgeTerm: /(?-u:\b)clock_posedge(?-u:\b)/ : Token; /* 52 */ ClockNegedgeTerm: /(?-u:\b)clock_negedge(?-u:\b)/ : Token; -/* 53 */ DefaultTerm: /(?-u:\b)default(?-u:\b)/ : Token; -/* 54 */ ElseTerm: /(?-u:\b)else(?-u:\b)/ : Token; -/* 55 */ EmbedTerm: /(?-u:\b)embed(?-u:\b)/ : Token; -/* 56 */ EnumTerm: /(?-u:\b)enum(?-u:\b)/ : Token; -/* 57 */ ExportTerm: /(?-u:\b)export(?-u:\b)/ : Token; -/* 58 */ F32Term: /(?-u:\b)f32(?-u:\b)/ : Token; -/* 59 */ F64Term: /(?-u:\b)f64(?-u:\b)/ : Token; -/* 60 */ FinalTerm: /(?-u:\b)final(?-u:\b)/ : Token; -/* 61 */ ForTerm: /(?-u:\b)for(?-u:\b)/ : Token; -/* 62 */ FunctionTerm: /(?-u:\b)function(?-u:\b)/ : Token; -/* 63 */ I32Term: /(?-u:\b)i32(?-u:\b)/ : Token; -/* 64 */ I64Term: /(?-u:\b)i64(?-u:\b)/ : Token; -/* 65 */ IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/ : Token; -/* 66 */ IfTerm: /(?-u:\b)if(?-u:\b)/ : Token; -/* 67 */ ImportTerm: /(?-u:\b)import(?-u:\b)/ : Token; -/* 68 */ IncludeTerm: /(?-u:\b)include(?-u:\b)/ : Token; -/* 69 */ InitialTerm: /(?-u:\b)initial(?-u:\b)/ : Token; -/* 70 */ InoutTerm: /(?-u:\b)inout(?-u:\b)/ : Token; -/* 71 */ InputTerm: /(?-u:\b)input(?-u:\b)/ : Token; -/* 72 */ InsideTerm: /(?-u:\b)inside(?-u:\b)/ : Token; -/* 73 */ InstTerm: /(?-u:\b)inst(?-u:\b)/ : Token; -/* 74 */ InterfaceTerm: /(?-u:\b)interface(?-u:\b)/ : Token; -/* 75 */ InTerm: /(?-u:\b)in(?-u:\b)/ : Token; -/* 76 */ LetTerm: /(?-u:\b)let(?-u:\b)/ : Token; -/* 77 */ LocalTerm: /(?-u:\b)local(?-u:\b)/ : Token; -/* 78 */ LogicTerm: /(?-u:\b)logic(?-u:\b)/ : Token; -/* 79 */ LsbTerm: /(?-u:\b)lsb(?-u:\b)/ : Token; -/* 80 */ ModportTerm: /(?-u:\b)modport(?-u:\b)/ : Token; -/* 81 */ ModuleTerm: /(?-u:\b)module(?-u:\b)/ : Token; -/* 82 */ MsbTerm: /(?-u:\b)msb(?-u:\b)/ : Token; -/* 83 */ OutputTerm: /(?-u:\b)output(?-u:\b)/ : Token; -/* 84 */ OutsideTerm: /(?-u:\b)outside(?-u:\b)/ : Token; -/* 85 */ PackageTerm: /(?-u:\b)package(?-u:\b)/ : Token; -/* 86 */ ParamTerm: /(?-u:\b)param(?-u:\b)/ : Token; -/* 87 */ PubTerm: /(?-u:\b)pub(?-u:\b)/ : Token; -/* 88 */ RefTerm: /(?-u:\b)ref(?-u:\b)/ : Token; -/* 89 */ RepeatTerm: /(?-u:\b)repeat(?-u:\b)/ : Token; -/* 90 */ ResetTerm: /(?-u:\b)reset(?-u:\b)/ : Token; -/* 91 */ ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/ : Token; -/* 92 */ ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/ : Token; -/* 93 */ ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/ : Token; -/* 94 */ ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/ : Token; -/* 95 */ ReturnTerm: /(?-u:\b)return(?-u:\b)/ : Token; -/* 96 */ BreakTerm: /(?-u:\b)break(?-u:\b)/ : Token; -/* 97 */ SignedTerm: /(?-u:\b)signed(?-u:\b)/ : Token; -/* 98 */ StepTerm: /(?-u:\b)step(?-u:\b)/ : Token; -/* 99 */ StringTerm: /(?-u:\b)string(?-u:\b)/ : Token; -/* 100 */ StructTerm: /(?-u:\b)struct(?-u:\b)/ : Token; -/* 101 */ SwitchTerm: /(?-u:\b)switch(?-u:\b)/ : Token; -/* 102 */ TriTerm: /(?-u:\b)tri(?-u:\b)/ : Token; -/* 103 */ TypeTerm: /(?-u:\b)type(?-u:\b)/ : Token; -/* 104 */ U32Term: /(?-u:\b)u32(?-u:\b)/ : Token; -/* 105 */ U64Term: /(?-u:\b)u64(?-u:\b)/ : Token; -/* 106 */ UnionTerm: /(?-u:\b)union(?-u:\b)/ : Token; -/* 107 */ UnsafeTerm: /(?-u:\b)unsafe(?-u:\b)/ : Token; -/* 108 */ VarTerm: /(?-u:\b)var(?-u:\b)/ : Token; -/* 109 */ DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; -/* 110 */ IdentifierTerm: /(?:r#)?[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; -/* 111 */ AnyTerm: /[^{}]*/ : Token; -/* 112 */ Comments: CommentsOpt /* Option */; -/* 113 */ CommentsOpt /* Option::Some */: CommentsTerm; -/* 114 */ CommentsOpt /* Option::None */: ; -/* 115 */ StartToken: Comments; -/* 116 */ StringLiteralToken: StringLiteralTerm : Token Comments; -/* 117 */ ExponentToken: ExponentTerm : Token Comments; -/* 118 */ FixedPointToken: FixedPointTerm : Token Comments; -/* 119 */ BasedToken: BasedTerm : Token Comments; -/* 120 */ BaseLessToken: BaseLessTerm : Token Comments; -/* 121 */ AllBitToken: AllBitTerm : Token Comments; -/* 122 */ AssignmentOperatorToken: AssignmentOperatorTerm : Token Comments; -/* 123 */ Operator01Token: Operator01Term : Token Comments; -/* 124 */ Operator02Token: Operator02Term : Token Comments; -/* 125 */ Operator03Token: Operator03Term : Token Comments; -/* 126 */ Operator04Token: Operator04Term : Token Comments; -/* 127 */ Operator05Token: Operator05Term : Token Comments; -/* 128 */ Operator06Token: Operator06Term : Token Comments; -/* 129 */ Operator07Token: Operator07Term : Token Comments; -/* 130 */ Operator08Token: Operator08Term : Token Comments; -/* 131 */ Operator09Token: Operator09Term : Token Comments; -/* 132 */ Operator10Token: Operator10Term : Token Comments; -/* 133 */ Operator11Token: Operator11Term : Token Comments; -/* 134 */ UnaryOperatorToken: UnaryOperatorTerm : Token Comments; -/* 135 */ BackQuoteToken: BackQuoteTerm : Token Comments; -/* 136 */ ColonToken: ColonTerm : Token Comments; -/* 137 */ ColonColonLAngleToken: ColonColonLAngleTerm : Token Comments; -/* 138 */ ColonColonToken: ColonColonTerm : Token Comments; -/* 139 */ CommaToken: CommaTerm : Token Comments; -/* 140 */ DotDotToken: DotDotTerm : Token Comments; -/* 141 */ DotDotEquToken: DotDotEquTerm : Token Comments; -/* 142 */ DotToken: DotTerm : Token Comments; -/* 143 */ EquToken: EquTerm : Token Comments; -/* 144 */ HashToken: HashTerm : Token Comments; -/* 145 */ QuoteLBraceToken: QuoteLBraceTerm : Token Comments; -/* 146 */ LAngleToken: LAngleTerm : Token Comments; -/* 147 */ LBraceToken: LBraceTerm : Token Comments; -/* 148 */ LBracketToken: LBracketTerm : Token Comments; -/* 149 */ LParenToken: LParenTerm : Token Comments; -/* 150 */ MinusColonToken: MinusColonTerm : Token Comments; -/* 151 */ MinusGTToken: MinusGTTerm : Token Comments; -/* 152 */ PlusColonToken: PlusColonTerm : Token Comments; -/* 153 */ RAngleToken: RAngleTerm : Token Comments; -/* 154 */ RBraceToken: RBraceTerm : Token Comments; -/* 155 */ RBracketToken: RBracketTerm : Token Comments; -/* 156 */ RParenToken: RParenTerm : Token Comments; -/* 157 */ SemicolonToken: SemicolonTerm : Token Comments; -/* 158 */ StarToken: StarTerm : Token Comments; -/* 159 */ AlwaysCombToken: AlwaysCombTerm : Token Comments; -/* 160 */ AlwaysFfToken: AlwaysFfTerm : Token Comments; -/* 161 */ AsToken: AsTerm : Token Comments; -/* 162 */ AssignToken: AssignTerm : Token Comments; -/* 163 */ BitToken: BitTerm : Token Comments; -/* 164 */ CaseToken: CaseTerm : Token Comments; -/* 165 */ ClockToken: ClockTerm : Token Comments; -/* 166 */ ClockPosedgeToken: ClockPosedgeTerm : Token Comments; -/* 167 */ ClockNegedgeToken: ClockNegedgeTerm : Token Comments; -/* 168 */ DefaultToken: DefaultTerm : Token Comments; -/* 169 */ ElseToken: ElseTerm : Token Comments; -/* 170 */ EmbedToken: EmbedTerm : Token Comments; -/* 171 */ EnumToken: EnumTerm : Token Comments; -/* 172 */ ExportToken: ExportTerm : Token Comments; -/* 173 */ F32Token: F32Term : Token Comments; -/* 174 */ F64Token: F64Term : Token Comments; -/* 175 */ FinalToken: FinalTerm : Token Comments; -/* 176 */ ForToken: ForTerm : Token Comments; -/* 177 */ FunctionToken: FunctionTerm : Token Comments; -/* 178 */ I32Token: I32Term : Token Comments; -/* 179 */ I64Token: I64Term : Token Comments; -/* 180 */ IfResetToken: IfResetTerm : Token Comments; -/* 181 */ IfToken: IfTerm : Token Comments; -/* 182 */ ImportToken: ImportTerm : Token Comments; -/* 183 */ IncludeToken: IncludeTerm : Token Comments; -/* 184 */ InitialToken: InitialTerm : Token Comments; -/* 185 */ InoutToken: InoutTerm : Token Comments; -/* 186 */ InputToken: InputTerm : Token Comments; -/* 187 */ InsideToken: InsideTerm : Token Comments; -/* 188 */ InstToken: InstTerm : Token Comments; -/* 189 */ InterfaceToken: InterfaceTerm : Token Comments; -/* 190 */ InToken: InTerm : Token Comments; -/* 191 */ LetToken: LetTerm : Token Comments; -/* 192 */ LocalToken: LocalTerm : Token Comments; -/* 193 */ LogicToken: LogicTerm : Token Comments; -/* 194 */ LsbToken: LsbTerm : Token Comments; -/* 195 */ ModportToken: ModportTerm : Token Comments; -/* 196 */ ModuleToken: ModuleTerm : Token Comments; -/* 197 */ MsbToken: MsbTerm : Token Comments; -/* 198 */ OutputToken: OutputTerm : Token Comments; -/* 199 */ OutsideToken: OutsideTerm : Token Comments; -/* 200 */ PackageToken: PackageTerm : Token Comments; -/* 201 */ ParamToken: ParamTerm : Token Comments; -/* 202 */ PubToken: PubTerm : Token Comments; -/* 203 */ RefToken: RefTerm : Token Comments; -/* 204 */ RepeatToken: RepeatTerm : Token Comments; -/* 205 */ ResetToken: ResetTerm : Token Comments; -/* 206 */ ResetAsyncHighToken: ResetAsyncHighTerm : Token Comments; -/* 207 */ ResetAsyncLowToken: ResetAsyncLowTerm : Token Comments; -/* 208 */ ResetSyncHighToken: ResetSyncHighTerm : Token Comments; -/* 209 */ ResetSyncLowToken: ResetSyncLowTerm : Token Comments; -/* 210 */ ReturnToken: ReturnTerm : Token Comments; -/* 211 */ BreakToken: BreakTerm : Token Comments; -/* 212 */ SignedToken: SignedTerm : Token Comments; -/* 213 */ StepToken: StepTerm : Token Comments; -/* 214 */ StringToken: StringTerm : Token Comments; -/* 215 */ StructToken: StructTerm : Token Comments; -/* 216 */ SwitchToken: SwitchTerm : Token Comments; -/* 217 */ TriToken: TriTerm : Token Comments; -/* 218 */ TypeToken: TypeTerm : Token Comments; -/* 219 */ U32Token: U32Term : Token Comments; -/* 220 */ U64Token: U64Term : Token Comments; -/* 221 */ UnionToken: UnionTerm : Token Comments; -/* 222 */ UnsafeToken: UnsafeTerm : Token Comments; -/* 223 */ VarToken: VarTerm : Token Comments; -/* 224 */ DollarIdentifierToken: DollarIdentifierTerm : Token Comments; -/* 225 */ IdentifierToken: IdentifierTerm : Token Comments; -/* 226 */ Start: StartToken : VerylToken; -/* 227 */ StringLiteral: StringLiteralToken : VerylToken; -/* 228 */ Exponent: ExponentToken : VerylToken; -/* 229 */ FixedPoint: FixedPointToken : VerylToken; -/* 230 */ Based: BasedToken : VerylToken; -/* 231 */ BaseLess: BaseLessToken : VerylToken; -/* 232 */ AllBit: AllBitToken : VerylToken; -/* 233 */ AssignmentOperator: AssignmentOperatorToken : VerylToken; -/* 234 */ Operator01: Operator01Token : VerylToken; -/* 235 */ Operator02: Operator02Token : VerylToken; -/* 236 */ Operator03: Operator03Token : VerylToken; -/* 237 */ Operator04: Operator04Token : VerylToken; -/* 238 */ Operator05: Operator05Token : VerylToken; -/* 239 */ Operator06: Operator06Token : VerylToken; -/* 240 */ Operator07: Operator07Token : VerylToken; -/* 241 */ Operator08: Operator08Token : VerylToken; -/* 242 */ Operator09: Operator09Token : VerylToken; -/* 243 */ Operator10: Operator10Token : VerylToken; -/* 244 */ Operator11: Operator11Token : VerylToken; -/* 245 */ UnaryOperator: UnaryOperatorToken : VerylToken; -/* 246 */ BackQuote: BackQuoteToken : VerylToken; -/* 247 */ Colon: ColonToken : VerylToken; -/* 248 */ ColonColonLAngle: ColonColonLAngleToken : VerylToken; -/* 249 */ ColonColon: ColonColonToken : VerylToken; -/* 250 */ Comma: CommaToken : VerylToken; -/* 251 */ DotDot: DotDotToken : VerylToken; -/* 252 */ DotDotEqu: DotDotEquToken : VerylToken; -/* 253 */ Dot: DotToken : VerylToken; -/* 254 */ Equ: EquToken : VerylToken; -/* 255 */ Hash: HashToken : VerylToken; -/* 256 */ QuoteLBrace: QuoteLBraceToken : VerylToken; -/* 257 */ LAngle: LAngleToken : VerylToken; -/* 258 */ LBrace: LBraceToken : VerylToken; -/* 259 */ LBracket: LBracketToken : VerylToken; -/* 260 */ LParen: LParenToken : VerylToken; -/* 261 */ MinusColon: MinusColonToken : VerylToken; -/* 262 */ MinusGT: MinusGTToken : VerylToken; -/* 263 */ PlusColon: PlusColonToken : VerylToken; -/* 264 */ RAngle: RAngleToken : VerylToken; -/* 265 */ RBrace: RBraceToken : VerylToken; -/* 266 */ RBracket: RBracketToken : VerylToken; -/* 267 */ RParen: RParenToken : VerylToken; -/* 268 */ Semicolon: SemicolonToken : VerylToken; -/* 269 */ Star: StarToken : VerylToken; -/* 270 */ AlwaysComb: AlwaysCombToken : VerylToken; -/* 271 */ AlwaysFf: AlwaysFfToken : VerylToken; -/* 272 */ As: AsToken : VerylToken; -/* 273 */ Assign: AssignToken : VerylToken; -/* 274 */ Bit: BitToken : VerylToken; -/* 275 */ Break: BreakToken : VerylToken; -/* 276 */ Case: CaseToken : VerylToken; -/* 277 */ Clock: ClockToken : VerylToken; -/* 278 */ ClockPosedge: ClockPosedgeToken : VerylToken; -/* 279 */ ClockNegedge: ClockNegedgeToken : VerylToken; -/* 280 */ Defaul: DefaultToken : VerylToken; -/* 281 */ Else: ElseToken : VerylToken; -/* 282 */ Embed: EmbedToken : VerylToken; -/* 283 */ Enum: EnumToken : VerylToken; -/* 284 */ Export: ExportToken : VerylToken; -/* 285 */ F32: F32Token : VerylToken; -/* 286 */ F64: F64Token : VerylToken; -/* 287 */ Final: FinalToken : VerylToken; -/* 288 */ For: ForToken : VerylToken; -/* 289 */ Function: FunctionToken : VerylToken; -/* 290 */ I32: I32Token : VerylToken; -/* 291 */ I64: I64Token : VerylToken; -/* 292 */ If: IfToken : VerylToken; -/* 293 */ IfReset: IfResetToken : VerylToken; -/* 294 */ Import: ImportToken : VerylToken; -/* 295 */ In: InToken : VerylToken; -/* 296 */ Include: IncludeToken : VerylToken; -/* 297 */ Initial: InitialToken : VerylToken; -/* 298 */ Inout: InoutToken : VerylToken; -/* 299 */ Input: InputToken : VerylToken; -/* 300 */ Inside: InsideToken : VerylToken; -/* 301 */ Inst: InstToken : VerylToken; -/* 302 */ Interface: InterfaceToken : VerylToken; -/* 303 */ Let: LetToken : VerylToken; -/* 304 */ Local: LocalToken : VerylToken; -/* 305 */ Logic: LogicToken : VerylToken; -/* 306 */ Lsb: LsbToken : VerylToken; -/* 307 */ Modport: ModportToken : VerylToken; -/* 308 */ Module: ModuleToken : VerylToken; -/* 309 */ Msb: MsbToken : VerylToken; -/* 310 */ Output: OutputToken : VerylToken; -/* 311 */ Outside: OutsideToken : VerylToken; -/* 312 */ Package: PackageToken : VerylToken; -/* 313 */ Param: ParamToken : VerylToken; -/* 314 */ Pub: PubToken : VerylToken; -/* 315 */ Ref: RefToken : VerylToken; -/* 316 */ Repeat: RepeatToken : VerylToken; -/* 317 */ Reset: ResetToken : VerylToken; -/* 318 */ ResetAsyncHigh: ResetAsyncHighToken : VerylToken; -/* 319 */ ResetAsyncLow: ResetAsyncLowToken : VerylToken; -/* 320 */ ResetSyncHigh: ResetSyncHighToken : VerylToken; -/* 321 */ ResetSyncLow: ResetSyncLowToken : VerylToken; -/* 322 */ Return: ReturnToken : VerylToken; -/* 323 */ Signed: SignedToken : VerylToken; -/* 324 */ Step: StepToken : VerylToken; -/* 325 */ Strin: StringToken : VerylToken; -/* 326 */ Struct: StructToken : VerylToken; -/* 327 */ Switch: SwitchToken : VerylToken; -/* 328 */ Tri: TriToken : VerylToken; -/* 329 */ Type: TypeToken : VerylToken; -/* 330 */ U32: U32Token : VerylToken; -/* 331 */ U64: U64Token : VerylToken; -/* 332 */ Union: UnionToken : VerylToken; -/* 333 */ Unsafe: UnsafeToken : VerylToken; -/* 334 */ Var: VarToken : VerylToken; -/* 335 */ DollarIdentifier: DollarIdentifierToken : VerylToken; -/* 336 */ Identifier: IdentifierToken : VerylToken; -/* 337 */ Number: IntegralNumber; -/* 338 */ Number: RealNumber; -/* 339 */ IntegralNumber: Based; -/* 340 */ IntegralNumber: BaseLess; -/* 341 */ IntegralNumber: AllBit; -/* 342 */ RealNumber: FixedPoint; -/* 343 */ RealNumber: Exponent; -/* 344 */ HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; -/* 345 */ HierarchicalIdentifierList0 /* Vec::Push */: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; -/* 346 */ HierarchicalIdentifierList0List /* Vec::Push */: Select HierarchicalIdentifierList0List; -/* 347 */ HierarchicalIdentifierList0List /* Vec::New */: ; -/* 348 */ HierarchicalIdentifierList0 /* Vec::New */: ; -/* 349 */ HierarchicalIdentifierList /* Vec::Push */: Select HierarchicalIdentifierList; -/* 350 */ HierarchicalIdentifierList /* Vec::New */: ; -/* 351 */ ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; -/* 352 */ ScopedIdentifierGroup: DollarIdentifier; -/* 353 */ ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */; -/* 354 */ ScopedIdentifierList /* Vec::Push */: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList; -/* 355 */ ScopedIdentifierList /* Vec::New */: ; -/* 356 */ ScopedIdentifierOpt0 /* Option::Some */: WithGenericArgument; -/* 357 */ ScopedIdentifierOpt0 /* Option::None */: ; -/* 358 */ ScopedIdentifierOpt /* Option::Some */: WithGenericArgument; -/* 359 */ ScopedIdentifierOpt /* Option::None */: ; -/* 360 */ ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; -/* 361 */ ExpressionIdentifierList0 /* Vec::Push */: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; -/* 362 */ ExpressionIdentifierList0List /* Vec::Push */: Select ExpressionIdentifierList0List; -/* 363 */ ExpressionIdentifierList0List /* Vec::New */: ; -/* 364 */ ExpressionIdentifierList0 /* Vec::New */: ; -/* 365 */ ExpressionIdentifierList /* Vec::Push */: Select ExpressionIdentifierList; -/* 366 */ ExpressionIdentifierList /* Vec::New */: ; -/* 367 */ Expression: Expression01 ExpressionList /* Vec */; -/* 368 */ ExpressionList /* Vec::Push */: Operator01 Expression01 ExpressionList; -/* 369 */ ExpressionList /* Vec::New */: ; -/* 370 */ Expression01: Expression02 Expression01List /* Vec */; -/* 371 */ Expression01List /* Vec::Push */: Operator02 Expression02 Expression01List; -/* 372 */ Expression01List /* Vec::New */: ; -/* 373 */ Expression02: Expression03 Expression02List /* Vec */; -/* 374 */ Expression02List /* Vec::Push */: Operator03 Expression03 Expression02List; -/* 375 */ Expression02List /* Vec::New */: ; -/* 376 */ Expression03: Expression04 Expression03List /* Vec */; -/* 377 */ Expression03List /* Vec::Push */: Operator04 Expression04 Expression03List; -/* 378 */ Expression03List /* Vec::New */: ; -/* 379 */ Expression04: Expression05 Expression04List /* Vec */; -/* 380 */ Expression04List /* Vec::Push */: Operator05 Expression05 Expression04List; -/* 381 */ Expression04List /* Vec::New */: ; -/* 382 */ Expression05: Expression06 Expression05List /* Vec */; -/* 383 */ Expression05List /* Vec::Push */: Operator06 Expression06 Expression05List; -/* 384 */ Expression05List /* Vec::New */: ; -/* 385 */ Expression06: Expression07 Expression06List /* Vec */; -/* 386 */ Expression06List /* Vec::Push */: Operator07 Expression07 Expression06List; -/* 387 */ Expression06List /* Vec::New */: ; -/* 388 */ Expression07: Expression08 Expression07List /* Vec */; -/* 389 */ Expression07List /* Vec::Push */: Operator08 Expression08 Expression07List; -/* 390 */ Expression07List /* Vec::New */: ; -/* 391 */ Expression08: Expression09 Expression08List /* Vec */; -/* 392 */ Expression08List /* Vec::Push */: Operator09 Expression09 Expression08List; -/* 393 */ Expression08List /* Vec::New */: ; -/* 394 */ Expression09: Expression10 Expression09List /* Vec */; -/* 395 */ Expression09List /* Vec::Push */: Expression09ListGroup Expression10 Expression09List; -/* 396 */ Expression09ListGroup: Operator10; -/* 397 */ Expression09ListGroup: Star; -/* 398 */ Expression09List /* Vec::New */: ; -/* 399 */ Expression10: Expression11 Expression10List /* Vec */; -/* 400 */ Expression10List /* Vec::Push */: Operator11 Expression11 Expression10List; -/* 401 */ Expression10List /* Vec::New */: ; -/* 402 */ Expression11: Expression12 Expression11Opt /* Option */; -/* 403 */ Expression11Opt /* Option::Some */: As CastingType; -/* 404 */ Expression11Opt /* Option::None */: ; -/* 405 */ Expression12: Expression12List /* Vec */ Factor; -/* 406 */ Expression12List /* Vec::Push */: Expression12ListGroup Expression12List; -/* 407 */ Expression12ListGroup: UnaryOperator; -/* 408 */ Expression12ListGroup: Operator09; -/* 409 */ Expression12ListGroup: Operator05; -/* 410 */ Expression12ListGroup: Operator03; -/* 411 */ Expression12ListGroup: Operator04; -/* 412 */ Expression12List /* Vec::New */: ; -/* 413 */ Factor: Number; -/* 414 */ Factor: ExpressionIdentifier FactorOpt /* Option */; -/* 415 */ Factor: LParen Expression RParen; -/* 416 */ Factor: LBrace ConcatenationList RBrace; -/* 417 */ Factor: QuoteLBrace ArrayLiteralList RBrace; -/* 418 */ Factor: IfExpression; -/* 419 */ Factor: CaseExpression; -/* 420 */ Factor: SwitchExpression; -/* 421 */ Factor: StringLiteral; -/* 422 */ Factor: FactorGroup; -/* 423 */ FactorGroup: Msb; -/* 424 */ FactorGroup: Lsb; -/* 425 */ Factor: InsideExpression; -/* 426 */ Factor: OutsideExpression; -/* 427 */ FactorOpt /* Option::Some */: FunctionCall; -/* 428 */ FactorOpt /* Option::None */: ; -/* 429 */ FunctionCall: LParen FunctionCallOpt /* Option */ RParen; -/* 430 */ FunctionCallOpt /* Option::Some */: ArgumentList; -/* 431 */ FunctionCallOpt /* Option::None */: ; -/* 432 */ ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; -/* 433 */ ArgumentListList /* Vec::Push */: Comma ArgumentItem ArgumentListList; -/* 434 */ ArgumentListList /* Vec::New */: ; -/* 435 */ ArgumentListOpt /* Option::Some */: Comma; -/* 436 */ ArgumentListOpt /* Option::None */: ; -/* 437 */ ArgumentItem: Expression; -/* 438 */ ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; -/* 439 */ ConcatenationListList /* Vec::Push */: Comma ConcatenationItem ConcatenationListList; -/* 440 */ ConcatenationListList /* Vec::New */: ; -/* 441 */ ConcatenationListOpt /* Option::Some */: Comma; -/* 442 */ ConcatenationListOpt /* Option::None */: ; -/* 443 */ ConcatenationItem: Expression ConcatenationItemOpt /* Option */; -/* 444 */ ConcatenationItemOpt /* Option::Some */: Repeat Expression; -/* 445 */ ConcatenationItemOpt /* Option::None */: ; -/* 446 */ ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; -/* 447 */ ArrayLiteralListList /* Vec::Push */: Comma ArrayLiteralItem ArrayLiteralListList; -/* 448 */ ArrayLiteralListList /* Vec::New */: ; -/* 449 */ ArrayLiteralListOpt /* Option::Some */: Comma; -/* 450 */ ArrayLiteralListOpt /* Option::None */: ; -/* 451 */ ArrayLiteralItem: ArrayLiteralItemGroup; -/* 452 */ ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; -/* 453 */ ArrayLiteralItemGroup: Defaul Colon Expression; -/* 454 */ ArrayLiteralItemOpt /* Option::Some */: Repeat Expression; -/* 455 */ ArrayLiteralItemOpt /* Option::None */: ; -/* 456 */ IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; -/* 457 */ IfExpressionList /* Vec::Push */: Else If Expression LBrace Expression RBrace IfExpressionList; -/* 458 */ IfExpressionList /* Vec::New */: ; -/* 459 */ CaseExpression: Case Expression LBrace CaseCondition Colon Expression Comma CaseExpressionList /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; -/* 460 */ CaseExpressionList /* Vec::Push */: CaseCondition Colon Expression Comma CaseExpressionList; -/* 461 */ CaseExpressionList /* Vec::New */: ; -/* 462 */ CaseExpressionOpt /* Option::Some */: Comma; -/* 463 */ CaseExpressionOpt /* Option::None */: ; -/* 464 */ SwitchExpression: Switch LBrace SwitchCondition Colon Expression Comma SwitchExpressionList /* Vec */ Defaul Colon Expression SwitchExpressionOpt /* Option */ RBrace; -/* 465 */ SwitchExpressionList /* Vec::Push */: SwitchCondition Colon Expression Comma SwitchExpressionList; -/* 466 */ SwitchExpressionList /* Vec::New */: ; -/* 467 */ SwitchExpressionOpt /* Option::Some */: Comma; -/* 468 */ SwitchExpressionOpt /* Option::None */: ; -/* 469 */ TypeExpression: ScalarType; -/* 470 */ TypeExpression: Type LParen Expression RParen; -/* 471 */ InsideExpression: Inside Expression LBrace RangeList RBrace; -/* 472 */ OutsideExpression: Outside Expression LBrace RangeList RBrace; -/* 473 */ RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; -/* 474 */ RangeListList /* Vec::Push */: Comma RangeItem RangeListList; -/* 475 */ RangeListList /* Vec::New */: ; -/* 476 */ RangeListOpt /* Option::Some */: Comma; -/* 477 */ RangeListOpt /* Option::None */: ; -/* 478 */ RangeItem: Range; -/* 479 */ Select: LBracket Expression SelectOpt /* Option */ RBracket; -/* 480 */ SelectOpt /* Option::Some */: SelectOperator Expression; -/* 481 */ SelectOpt /* Option::None */: ; -/* 482 */ SelectOperator: Colon; -/* 483 */ SelectOperator: PlusColon; -/* 484 */ SelectOperator: MinusColon; -/* 485 */ SelectOperator: Step; -/* 486 */ Width: LAngle Expression WidthList /* Vec */ RAngle; -/* 487 */ WidthList /* Vec::Push */: Comma Expression WidthList; -/* 488 */ WidthList /* Vec::New */: ; -/* 489 */ Array: LBracket Expression ArrayList /* Vec */ RBracket; -/* 490 */ ArrayList /* Vec::Push */: Comma Expression ArrayList; -/* 491 */ ArrayList /* Vec::New */: ; -/* 492 */ Range: Expression RangeOpt /* Option */; -/* 493 */ RangeOpt /* Option::Some */: RangeOperator Expression; -/* 494 */ RangeOpt /* Option::None */: ; -/* 495 */ RangeOperator: DotDot; -/* 496 */ RangeOperator: DotDotEqu; -/* 497 */ FixedType: U32; -/* 498 */ FixedType: U64; -/* 499 */ FixedType: I32; -/* 500 */ FixedType: I64; -/* 501 */ FixedType: F32; -/* 502 */ FixedType: F64; -/* 503 */ FixedType: Strin; -/* 504 */ VariableType: VariableTypeGroup VariableTypeOpt /* Option */; -/* 505 */ VariableTypeGroup: Clock; -/* 506 */ VariableTypeGroup: ClockPosedge; -/* 507 */ VariableTypeGroup: ClockNegedge; -/* 508 */ VariableTypeGroup: Reset; -/* 509 */ VariableTypeGroup: ResetAsyncHigh; -/* 510 */ VariableTypeGroup: ResetAsyncLow; -/* 511 */ VariableTypeGroup: ResetSyncHigh; -/* 512 */ VariableTypeGroup: ResetSyncLow; -/* 513 */ VariableTypeGroup: Logic; -/* 514 */ VariableTypeGroup: Bit; -/* 515 */ VariableTypeGroup: ScopedIdentifier; -/* 516 */ VariableTypeOpt /* Option::Some */: Width; -/* 517 */ VariableTypeOpt /* Option::None */: ; -/* 518 */ TypeModifier: Tri; -/* 519 */ TypeModifier: Signed; -/* 520 */ ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; -/* 521 */ ScalarTypeGroup: VariableType; -/* 522 */ ScalarTypeGroup: FixedType; -/* 523 */ ScalarTypeList /* Vec::Push */: TypeModifier ScalarTypeList; -/* 524 */ ScalarTypeList /* Vec::New */: ; -/* 525 */ ArrayType: ScalarType ArrayTypeOpt /* Option */; -/* 526 */ ArrayTypeOpt /* Option::Some */: Array; -/* 527 */ ArrayTypeOpt /* Option::None */: ; -/* 528 */ CastingType: U32; -/* 529 */ CastingType: U64; -/* 530 */ CastingType: I32; -/* 531 */ CastingType: I64; -/* 532 */ CastingType: F32; -/* 533 */ CastingType: F64; -/* 534 */ CastingType: Clock; -/* 535 */ CastingType: ClockPosedge; -/* 536 */ CastingType: ClockNegedge; -/* 537 */ CastingType: Reset; -/* 538 */ CastingType: ResetAsyncHigh; -/* 539 */ CastingType: ResetAsyncLow; -/* 540 */ CastingType: ResetSyncHigh; -/* 541 */ CastingType: ResetSyncLow; -/* 542 */ CastingType: ScopedIdentifier; -/* 543 */ ClockDomain: BackQuote Identifier; -/* 544 */ Statement: LetStatement; -/* 545 */ Statement: IdentifierStatement; -/* 546 */ Statement: IfStatement; -/* 547 */ Statement: IfResetStatement; -/* 548 */ Statement: ReturnStatement; -/* 549 */ Statement: BreakStatement; -/* 550 */ Statement: ForStatement; -/* 551 */ Statement: CaseStatement; -/* 552 */ Statement: SwitchStatement; -/* 553 */ LetStatement: Let Identifier Colon LetStatementOpt /* Option */ ArrayType Equ Expression Semicolon; -/* 554 */ LetStatementOpt /* Option::Some */: ClockDomain; -/* 555 */ LetStatementOpt /* Option::None */: ; -/* 556 */ IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; -/* 557 */ IdentifierStatementGroup: FunctionCall; -/* 558 */ IdentifierStatementGroup: Assignment; -/* 559 */ Assignment: AssignmentGroup Expression; -/* 560 */ AssignmentGroup: Equ; -/* 561 */ AssignmentGroup: AssignmentOperator; -/* 562 */ IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; -/* 563 */ IfStatementList0 /* Vec::Push */: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; -/* 564 */ IfStatementList0List /* Vec::Push */: Statement IfStatementList0List; -/* 565 */ IfStatementList0List /* Vec::New */: ; -/* 566 */ IfStatementList0 /* Vec::New */: ; -/* 567 */ IfStatementList /* Vec::Push */: Statement IfStatementList; -/* 568 */ IfStatementList /* Vec::New */: ; -/* 569 */ IfStatementOpt /* Option::Some */: Else LBrace IfStatementOptList /* Vec */ RBrace; -/* 570 */ IfStatementOptList /* Vec::Push */: Statement IfStatementOptList; -/* 571 */ IfStatementOptList /* Vec::New */: ; -/* 572 */ IfStatementOpt /* Option::None */: ; -/* 573 */ IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; -/* 574 */ IfResetStatementList0 /* Vec::Push */: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; -/* 575 */ IfResetStatementList0List /* Vec::Push */: Statement IfResetStatementList0List; -/* 576 */ IfResetStatementList0List /* Vec::New */: ; -/* 577 */ IfResetStatementList0 /* Vec::New */: ; -/* 578 */ IfResetStatementList /* Vec::Push */: Statement IfResetStatementList; -/* 579 */ IfResetStatementList /* Vec::New */: ; -/* 580 */ IfResetStatementOpt /* Option::Some */: Else LBrace IfResetStatementOptList /* Vec */ RBrace; -/* 581 */ IfResetStatementOptList /* Vec::Push */: Statement IfResetStatementOptList; -/* 582 */ IfResetStatementOptList /* Vec::New */: ; -/* 583 */ IfResetStatementOpt /* Option::None */: ; -/* 584 */ ReturnStatement: Return Expression Semicolon; -/* 585 */ BreakStatement: Break Semicolon; -/* 586 */ ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; -/* 587 */ ForStatementList /* Vec::Push */: Statement ForStatementList; -/* 588 */ ForStatementList /* Vec::New */: ; -/* 589 */ ForStatementOpt /* Option::Some */: Step AssignmentOperator Expression; -/* 590 */ ForStatementOpt /* Option::None */: ; -/* 591 */ CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; -/* 592 */ CaseStatementList /* Vec::Push */: CaseItem CaseStatementList; -/* 593 */ CaseStatementList /* Vec::New */: ; -/* 594 */ CaseItem: CaseItemGroup Colon CaseItemGroup0; -/* 595 */ CaseItemGroup0: Statement; -/* 596 */ CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; -/* 597 */ CaseItemGroup0List /* Vec::Push */: Statement CaseItemGroup0List; -/* 598 */ CaseItemGroup0List /* Vec::New */: ; -/* 599 */ CaseItemGroup: CaseCondition; -/* 600 */ CaseItemGroup: Defaul; -/* 601 */ CaseCondition: RangeItem CaseConditionList /* Vec */; -/* 602 */ CaseConditionList /* Vec::Push */: Comma RangeItem CaseConditionList; -/* 603 */ CaseConditionList /* Vec::New */: ; -/* 604 */ SwitchStatement: Switch LBrace SwitchStatementList /* Vec */ RBrace; -/* 605 */ SwitchStatementList /* Vec::Push */: SwitchItem SwitchStatementList; -/* 606 */ SwitchStatementList /* Vec::New */: ; -/* 607 */ SwitchItem: SwitchItemGroup Colon SwitchItemGroup0; -/* 608 */ SwitchItemGroup0: Statement; -/* 609 */ SwitchItemGroup0: LBrace SwitchItemGroup0List /* Vec */ RBrace; -/* 610 */ SwitchItemGroup0List /* Vec::Push */: Statement SwitchItemGroup0List; -/* 611 */ SwitchItemGroup0List /* Vec::New */: ; -/* 612 */ SwitchItemGroup: SwitchCondition; -/* 613 */ SwitchItemGroup: Defaul; -/* 614 */ SwitchCondition: Expression SwitchConditionList /* Vec */; -/* 615 */ SwitchConditionList /* Vec::Push */: Comma Expression SwitchConditionList; -/* 616 */ SwitchConditionList /* Vec::New */: ; -/* 617 */ Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; -/* 618 */ AttributeOpt /* Option::Some */: LParen AttributeList RParen; -/* 619 */ AttributeOpt /* Option::None */: ; -/* 620 */ AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; -/* 621 */ AttributeListList /* Vec::Push */: Comma AttributeItem AttributeListList; -/* 622 */ AttributeListList /* Vec::New */: ; -/* 623 */ AttributeListOpt /* Option::Some */: Comma; -/* 624 */ AttributeListOpt /* Option::None */: ; -/* 625 */ AttributeItem: Identifier; -/* 626 */ AttributeItem: StringLiteral; -/* 627 */ LetDeclaration: Let Identifier Colon LetDeclarationOpt /* Option */ ArrayType Equ Expression Semicolon; -/* 628 */ LetDeclarationOpt /* Option::Some */: ClockDomain; -/* 629 */ LetDeclarationOpt /* Option::None */: ; -/* 630 */ VarDeclaration: Var Identifier Colon VarDeclarationOpt /* Option */ ArrayType Semicolon; -/* 631 */ VarDeclarationOpt /* Option::Some */: ClockDomain; -/* 632 */ VarDeclarationOpt /* Option::None */: ; -/* 633 */ LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; -/* 634 */ LocalDeclarationGroup: ArrayType Equ Expression; -/* 635 */ LocalDeclarationGroup: Type Equ TypeExpression; -/* 636 */ TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; -/* 637 */ AlwaysFfDeclaration: AlwaysFf AlwaysFfDeclarationOpt /* Option */ LBrace AlwaysFfDeclarationList /* Vec */ RBrace; -/* 638 */ AlwaysFfDeclarationList /* Vec::Push */: Statement AlwaysFfDeclarationList; -/* 639 */ AlwaysFfDeclarationList /* Vec::New */: ; -/* 640 */ AlwaysFfDeclarationOpt /* Option::Some */: AlwayfFfEventList; -/* 641 */ AlwaysFfDeclarationOpt /* Option::None */: ; -/* 642 */ AlwayfFfEventList: LParen AlwaysFfClock AlwayfFfEventListOpt /* Option */ RParen; -/* 643 */ AlwayfFfEventListOpt /* Option::Some */: Comma AlwaysFfReset; -/* 644 */ AlwayfFfEventListOpt /* Option::None */: ; -/* 645 */ AlwaysFfClock: HierarchicalIdentifier; -/* 646 */ AlwaysFfReset: HierarchicalIdentifier; -/* 647 */ AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; -/* 648 */ AlwaysCombDeclarationList /* Vec::Push */: Statement AlwaysCombDeclarationList; -/* 649 */ AlwaysCombDeclarationList /* Vec::New */: ; -/* 650 */ AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; -/* 651 */ ModportDeclaration: Modport Identifier LBrace ModportList RBrace; -/* 652 */ ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; -/* 653 */ ModportListList /* Vec::Push */: Comma ModportGroup ModportListList; -/* 654 */ ModportListList /* Vec::New */: ; -/* 655 */ ModportListOpt /* Option::Some */: Comma; -/* 656 */ ModportListOpt /* Option::None */: ; -/* 657 */ ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; -/* 658 */ ModportGroupGroup: LBrace ModportList RBrace; -/* 659 */ ModportGroupGroup: ModportItem; -/* 660 */ ModportGroupList /* Vec::Push */: Attribute ModportGroupList; -/* 661 */ ModportGroupList /* Vec::New */: ; -/* 662 */ ModportItem: Identifier Colon Direction; -/* 663 */ EnumDeclaration: Enum Identifier EnumDeclarationOpt /* Option */ LBrace EnumList RBrace; -/* 664 */ EnumDeclarationOpt /* Option::Some */: Colon ScalarType; -/* 665 */ EnumDeclarationOpt /* Option::None */: ; -/* 666 */ EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; -/* 667 */ EnumListList /* Vec::Push */: Comma EnumGroup EnumListList; -/* 668 */ EnumListList /* Vec::New */: ; -/* 669 */ EnumListOpt /* Option::Some */: Comma; -/* 670 */ EnumListOpt /* Option::None */: ; -/* 671 */ EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; -/* 672 */ EnumGroupGroup: LBrace EnumList RBrace; -/* 673 */ EnumGroupGroup: EnumItem; -/* 674 */ EnumGroupList /* Vec::Push */: Attribute EnumGroupList; -/* 675 */ EnumGroupList /* Vec::New */: ; -/* 676 */ EnumItem: Identifier EnumItemOpt /* Option */; -/* 677 */ EnumItemOpt /* Option::Some */: Equ Expression; -/* 678 */ EnumItemOpt /* Option::None */: ; -/* 679 */ StructUnion: Struct; -/* 680 */ StructUnion: Union; -/* 681 */ StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace; -/* 682 */ StructUnionDeclarationOpt /* Option::Some */: WithGenericParameter; -/* 683 */ StructUnionDeclarationOpt /* Option::None */: ; -/* 684 */ StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; -/* 685 */ StructUnionListList /* Vec::Push */: Comma StructUnionGroup StructUnionListList; -/* 686 */ StructUnionListList /* Vec::New */: ; -/* 687 */ StructUnionListOpt /* Option::Some */: Comma; -/* 688 */ StructUnionListOpt /* Option::None */: ; -/* 689 */ StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; -/* 690 */ StructUnionGroupGroup: LBrace StructUnionList RBrace; -/* 691 */ StructUnionGroupGroup: StructUnionItem; -/* 692 */ StructUnionGroupList /* Vec::Push */: Attribute StructUnionGroupList; -/* 693 */ StructUnionGroupList /* Vec::New */: ; -/* 694 */ StructUnionItem: Identifier Colon ScalarType; -/* 695 */ InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; -/* 696 */ InitialDeclarationList /* Vec::Push */: Statement InitialDeclarationList; -/* 697 */ InitialDeclarationList /* Vec::New */: ; -/* 698 */ FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; -/* 699 */ FinalDeclarationList /* Vec::Push */: Statement FinalDeclarationList; -/* 700 */ FinalDeclarationList /* Vec::New */: ; -/* 701 */ InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; -/* 702 */ InstDeclarationOpt1 /* Option::Some */: LParen InstDeclarationOpt2 /* Option */ RParen; -/* 703 */ InstDeclarationOpt2 /* Option::Some */: InstPortList; -/* 704 */ InstDeclarationOpt2 /* Option::None */: ; -/* 705 */ InstDeclarationOpt1 /* Option::None */: ; -/* 706 */ InstDeclarationOpt0 /* Option::Some */: InstParameter; -/* 707 */ InstDeclarationOpt0 /* Option::None */: ; -/* 708 */ InstDeclarationOpt /* Option::Some */: Array; -/* 709 */ InstDeclarationOpt /* Option::None */: ; -/* 710 */ InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; -/* 711 */ InstParameterOpt /* Option::Some */: InstParameterList; -/* 712 */ InstParameterOpt /* Option::None */: ; -/* 713 */ InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; -/* 714 */ InstParameterListList /* Vec::Push */: Comma InstParameterGroup InstParameterListList; -/* 715 */ InstParameterListList /* Vec::New */: ; -/* 716 */ InstParameterListOpt /* Option::Some */: Comma; -/* 717 */ InstParameterListOpt /* Option::None */: ; -/* 718 */ InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; -/* 719 */ InstParameterGroupGroup: LBrace InstParameterList RBrace; -/* 720 */ InstParameterGroupGroup: InstParameterItem; -/* 721 */ InstParameterGroupList /* Vec::Push */: Attribute InstParameterGroupList; -/* 722 */ InstParameterGroupList /* Vec::New */: ; -/* 723 */ InstParameterItem: Identifier InstParameterItemOpt /* Option */; -/* 724 */ InstParameterItemOpt /* Option::Some */: Colon Expression; -/* 725 */ InstParameterItemOpt /* Option::None */: ; -/* 726 */ InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; -/* 727 */ InstPortListList /* Vec::Push */: Comma InstPortGroup InstPortListList; -/* 728 */ InstPortListList /* Vec::New */: ; -/* 729 */ InstPortListOpt /* Option::Some */: Comma; -/* 730 */ InstPortListOpt /* Option::None */: ; -/* 731 */ InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; -/* 732 */ InstPortGroupGroup: LBrace InstPortList RBrace; -/* 733 */ InstPortGroupGroup: InstPortItem; -/* 734 */ InstPortGroupList /* Vec::Push */: Attribute InstPortGroupList; -/* 735 */ InstPortGroupList /* Vec::New */: ; -/* 736 */ InstPortItem: Identifier InstPortItemOpt /* Option */; -/* 737 */ InstPortItemOpt /* Option::Some */: Colon Expression; -/* 738 */ InstPortItemOpt /* Option::None */: ; -/* 739 */ WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; -/* 740 */ WithParameterOpt /* Option::Some */: WithParameterList; -/* 741 */ WithParameterOpt /* Option::None */: ; -/* 742 */ WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; -/* 743 */ WithParameterListList /* Vec::Push */: Comma WithParameterGroup WithParameterListList; -/* 744 */ WithParameterListList /* Vec::New */: ; -/* 745 */ WithParameterListOpt /* Option::Some */: Comma; -/* 746 */ WithParameterListOpt /* Option::None */: ; -/* 747 */ WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; -/* 748 */ WithParameterGroupGroup: LBrace WithParameterList RBrace; -/* 749 */ WithParameterGroupGroup: WithParameterItem; -/* 750 */ WithParameterGroupList /* Vec::Push */: Attribute WithParameterGroupList; -/* 751 */ WithParameterGroupList /* Vec::New */: ; -/* 752 */ WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; -/* 753 */ WithParameterItemGroup0: ArrayType Equ Expression; -/* 754 */ WithParameterItemGroup0: Type Equ TypeExpression; -/* 755 */ WithParameterItemGroup: Param; -/* 756 */ WithParameterItemGroup: Local; -/* 757 */ WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; -/* 758 */ WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */; -/* 759 */ WithGenericParameterListList /* Vec::Push */: Comma WithGenericParameterItem WithGenericParameterListList; -/* 760 */ WithGenericParameterListList /* Vec::New */: ; -/* 761 */ WithGenericParameterListOpt /* Option::Some */: Comma; -/* 762 */ WithGenericParameterListOpt /* Option::None */: ; -/* 763 */ WithGenericParameterItem: Identifier WithGenericParameterItemOpt /* Option */; -/* 764 */ WithGenericParameterItemOpt /* Option::Some */: Equ WithGenericArgumentItem; -/* 765 */ WithGenericParameterItemOpt /* Option::None */: ; -/* 766 */ WithGenericArgument: ColonColonLAngle %push(Generic) WithGenericArgumentOpt /* Option */ RAngle %pop(); -/* 767 */ WithGenericArgumentOpt /* Option::Some */: WithGenericArgumentList; -/* 768 */ WithGenericArgumentOpt /* Option::None */: ; -/* 769 */ WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */; -/* 770 */ WithGenericArgumentListList /* Vec::Push */: Comma WithGenericArgumentItem WithGenericArgumentListList; -/* 771 */ WithGenericArgumentListList /* Vec::New */: ; -/* 772 */ WithGenericArgumentListOpt /* Option::Some */: Comma; -/* 773 */ WithGenericArgumentListOpt /* Option::None */: ; -/* 774 */ WithGenericArgumentItem: ScopedIdentifier; -/* 775 */ WithGenericArgumentItem: Number; -/* 776 */ PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; -/* 777 */ PortDeclarationOpt /* Option::Some */: PortDeclarationList; -/* 778 */ PortDeclarationOpt /* Option::None */: ; -/* 779 */ PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; -/* 780 */ PortDeclarationListList /* Vec::Push */: Comma PortDeclarationGroup PortDeclarationListList; -/* 781 */ PortDeclarationListList /* Vec::New */: ; -/* 782 */ PortDeclarationListOpt /* Option::Some */: Comma; -/* 783 */ PortDeclarationListOpt /* Option::None */: ; -/* 784 */ PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; -/* 785 */ PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; -/* 786 */ PortDeclarationGroupGroup: PortDeclarationItem; -/* 787 */ PortDeclarationGroupList /* Vec::Push */: Attribute PortDeclarationGroupList; -/* 788 */ PortDeclarationGroupList /* Vec::New */: ; -/* 789 */ PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; -/* 790 */ PortDeclarationItemGroup: PortTypeConcrete; -/* 791 */ PortDeclarationItemGroup: PortTypeAbstract; -/* 792 */ PortTypeConcrete: Direction PortTypeConcreteOpt /* Option */ ArrayType; -/* 793 */ PortTypeConcreteOpt /* Option::Some */: ClockDomain; -/* 794 */ PortTypeConcreteOpt /* Option::None */: ; -/* 795 */ PortTypeAbstract: PortTypeAbstractOpt /* Option */ Interface PortTypeAbstractOpt0 /* Option */; -/* 796 */ PortTypeAbstractOpt0 /* Option::Some */: Array; -/* 797 */ PortTypeAbstractOpt0 /* Option::None */: ; -/* 798 */ PortTypeAbstractOpt /* Option::Some */: ClockDomain; -/* 799 */ PortTypeAbstractOpt /* Option::None */: ; -/* 800 */ Direction: Input; -/* 801 */ Direction: Output; -/* 802 */ Direction: Inout; -/* 803 */ Direction: Ref; -/* 804 */ Direction: Modport; -/* 805 */ Direction: Import; -/* 806 */ FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; -/* 807 */ FunctionDeclarationList /* Vec::Push */: FunctionItem FunctionDeclarationList; -/* 808 */ FunctionDeclarationList /* Vec::New */: ; -/* 809 */ FunctionDeclarationOpt1 /* Option::Some */: MinusGT ScalarType; -/* 810 */ FunctionDeclarationOpt1 /* Option::None */: ; -/* 811 */ FunctionDeclarationOpt0 /* Option::Some */: PortDeclaration; -/* 812 */ FunctionDeclarationOpt0 /* Option::None */: ; -/* 813 */ FunctionDeclarationOpt /* Option::Some */: WithGenericParameter; -/* 814 */ FunctionDeclarationOpt /* Option::None */: ; -/* 815 */ FunctionItem: VarDeclaration; -/* 816 */ FunctionItem: Statement; -/* 817 */ ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; -/* 818 */ ImportDeclarationOpt /* Option::Some */: ColonColon Star; -/* 819 */ ImportDeclarationOpt /* Option::None */: ; -/* 820 */ ExportDeclaration: Export ExportDeclarationGroup Semicolon; -/* 821 */ ExportDeclarationGroup: Star; -/* 822 */ ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; -/* 823 */ ExportDeclarationOpt /* Option::Some */: ColonColon Star; -/* 824 */ ExportDeclarationOpt /* Option::None */: ; -/* 825 */ UnsafeBlock: Unsafe LParen Identifier RParen LBrace UnsafeBlockList /* Vec */ RBrace; -/* 826 */ UnsafeBlockList /* Vec::Push */: ModuleGroup UnsafeBlockList; -/* 827 */ UnsafeBlockList /* Vec::New */: ; -/* 828 */ ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; -/* 829 */ ModuleDeclarationList /* Vec::Push */: ModuleGroup ModuleDeclarationList; -/* 830 */ ModuleDeclarationList /* Vec::New */: ; -/* 831 */ ModuleDeclarationOpt2 /* Option::Some */: PortDeclaration; -/* 832 */ ModuleDeclarationOpt2 /* Option::None */: ; -/* 833 */ ModuleDeclarationOpt1 /* Option::Some */: WithParameter; -/* 834 */ ModuleDeclarationOpt1 /* Option::None */: ; -/* 835 */ ModuleDeclarationOpt0 /* Option::Some */: WithGenericParameter; -/* 836 */ ModuleDeclarationOpt0 /* Option::None */: ; -/* 837 */ ModuleDeclarationOpt /* Option::Some */: Pub; -/* 838 */ ModuleDeclarationOpt /* Option::None */: ; -/* 839 */ ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; -/* 840 */ ModuleIfDeclarationList /* Vec::Push */: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; -/* 841 */ ModuleIfDeclarationList /* Vec::New */: ; -/* 842 */ ModuleIfDeclarationOpt /* Option::Some */: Else ModuleOptionalNamedBlock; -/* 843 */ ModuleIfDeclarationOpt /* Option::None */: ; -/* 844 */ ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; -/* 845 */ ModuleForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; -/* 846 */ ModuleForDeclarationOpt /* Option::None */: ; -/* 847 */ ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; -/* 848 */ ModuleNamedBlockList /* Vec::Push */: ModuleGroup ModuleNamedBlockList; -/* 849 */ ModuleNamedBlockList /* Vec::New */: ; -/* 850 */ ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; -/* 851 */ ModuleOptionalNamedBlockList /* Vec::Push */: ModuleGroup ModuleOptionalNamedBlockList; -/* 852 */ ModuleOptionalNamedBlockList /* Vec::New */: ; -/* 853 */ ModuleOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; -/* 854 */ ModuleOptionalNamedBlockOpt /* Option::None */: ; -/* 855 */ ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; -/* 856 */ ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; -/* 857 */ ModuleGroupGroupList /* Vec::Push */: ModuleGroup ModuleGroupGroupList; -/* 858 */ ModuleGroupGroupList /* Vec::New */: ; -/* 859 */ ModuleGroupGroup: ModuleItem; -/* 860 */ ModuleGroupList /* Vec::Push */: Attribute ModuleGroupList; -/* 861 */ ModuleGroupList /* Vec::New */: ; -/* 862 */ ModuleItem: LetDeclaration; -/* 863 */ ModuleItem: VarDeclaration; -/* 864 */ ModuleItem: InstDeclaration; -/* 865 */ ModuleItem: TypeDefDeclaration; -/* 866 */ ModuleItem: LocalDeclaration; -/* 867 */ ModuleItem: AlwaysFfDeclaration; -/* 868 */ ModuleItem: AlwaysCombDeclaration; -/* 869 */ ModuleItem: AssignDeclaration; -/* 870 */ ModuleItem: FunctionDeclaration; -/* 871 */ ModuleItem: ModuleIfDeclaration; -/* 872 */ ModuleItem: ModuleForDeclaration; -/* 873 */ ModuleItem: EnumDeclaration; -/* 874 */ ModuleItem: StructUnionDeclaration; -/* 875 */ ModuleItem: ModuleNamedBlock; -/* 876 */ ModuleItem: ImportDeclaration; -/* 877 */ ModuleItem: InitialDeclaration; -/* 878 */ ModuleItem: FinalDeclaration; -/* 879 */ ModuleItem: UnsafeBlock; -/* 880 */ InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; -/* 881 */ InterfaceDeclarationList /* Vec::Push */: InterfaceGroup InterfaceDeclarationList; -/* 882 */ InterfaceDeclarationList /* Vec::New */: ; -/* 883 */ InterfaceDeclarationOpt1 /* Option::Some */: WithParameter; -/* 884 */ InterfaceDeclarationOpt1 /* Option::None */: ; -/* 885 */ InterfaceDeclarationOpt0 /* Option::Some */: WithGenericParameter; -/* 886 */ InterfaceDeclarationOpt0 /* Option::None */: ; -/* 887 */ InterfaceDeclarationOpt /* Option::Some */: Pub; -/* 888 */ InterfaceDeclarationOpt /* Option::None */: ; -/* 889 */ InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; -/* 890 */ InterfaceIfDeclarationList /* Vec::Push */: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; -/* 891 */ InterfaceIfDeclarationList /* Vec::New */: ; -/* 892 */ InterfaceIfDeclarationOpt /* Option::Some */: Else InterfaceOptionalNamedBlock; -/* 893 */ InterfaceIfDeclarationOpt /* Option::None */: ; -/* 894 */ InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; -/* 895 */ InterfaceForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; -/* 896 */ InterfaceForDeclarationOpt /* Option::None */: ; -/* 897 */ InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; -/* 898 */ InterfaceNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceNamedBlockList; -/* 899 */ InterfaceNamedBlockList /* Vec::New */: ; -/* 900 */ InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; -/* 901 */ InterfaceOptionalNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceOptionalNamedBlockList; -/* 902 */ InterfaceOptionalNamedBlockList /* Vec::New */: ; -/* 903 */ InterfaceOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; -/* 904 */ InterfaceOptionalNamedBlockOpt /* Option::None */: ; -/* 905 */ InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; -/* 906 */ InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; -/* 907 */ InterfaceGroupGroupList /* Vec::Push */: InterfaceGroup InterfaceGroupGroupList; -/* 908 */ InterfaceGroupGroupList /* Vec::New */: ; -/* 909 */ InterfaceGroupGroup: InterfaceItem; -/* 910 */ InterfaceGroupList /* Vec::Push */: Attribute InterfaceGroupList; -/* 911 */ InterfaceGroupList /* Vec::New */: ; -/* 912 */ InterfaceItem: LetDeclaration; -/* 913 */ InterfaceItem: VarDeclaration; -/* 914 */ InterfaceItem: LocalDeclaration; -/* 915 */ InterfaceItem: ModportDeclaration; -/* 916 */ InterfaceItem: InterfaceIfDeclaration; -/* 917 */ InterfaceItem: InterfaceForDeclaration; -/* 918 */ InterfaceItem: TypeDefDeclaration; -/* 919 */ InterfaceItem: EnumDeclaration; -/* 920 */ InterfaceItem: StructUnionDeclaration; -/* 921 */ InterfaceItem: InterfaceNamedBlock; -/* 922 */ InterfaceItem: FunctionDeclaration; -/* 923 */ InterfaceItem: ImportDeclaration; -/* 924 */ InterfaceItem: InitialDeclaration; -/* 925 */ InterfaceItem: FinalDeclaration; -/* 926 */ PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace; -/* 927 */ PackageDeclarationList /* Vec::Push */: PackageGroup PackageDeclarationList; -/* 928 */ PackageDeclarationList /* Vec::New */: ; -/* 929 */ PackageDeclarationOpt0 /* Option::Some */: WithGenericParameter; -/* 930 */ PackageDeclarationOpt0 /* Option::None */: ; -/* 931 */ PackageDeclarationOpt /* Option::Some */: Pub; -/* 932 */ PackageDeclarationOpt /* Option::None */: ; -/* 933 */ PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; -/* 934 */ PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; -/* 935 */ PackageGroupGroupList /* Vec::Push */: PackageGroup PackageGroupGroupList; -/* 936 */ PackageGroupGroupList /* Vec::New */: ; -/* 937 */ PackageGroupGroup: PackageItem; -/* 938 */ PackageGroupList /* Vec::Push */: Attribute PackageGroupList; -/* 939 */ PackageGroupList /* Vec::New */: ; -/* 940 */ PackageItem: VarDeclaration; -/* 941 */ PackageItem: LocalDeclaration; -/* 942 */ PackageItem: TypeDefDeclaration; -/* 943 */ PackageItem: EnumDeclaration; -/* 944 */ PackageItem: StructUnionDeclaration; -/* 945 */ PackageItem: FunctionDeclaration; -/* 946 */ PackageItem: ImportDeclaration; -/* 947 */ PackageItem: ExportDeclaration; -/* 948 */ PackageItem: InitialDeclaration; -/* 949 */ PackageItem: FinalDeclaration; -/* 950 */ EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; -/* 951 */ EmbedContent: EmbedContentToken : VerylToken; -/* 952 */ EmbedContentToken: LBraceTerm %push(Embed) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm %pop() Comments; -/* 953 */ EmbedContentTokenList /* Vec::Push */: EmbedItem EmbedContentTokenList; -/* 954 */ EmbedContentTokenList /* Vec::New */: ; -/* 955 */ EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; -/* 956 */ EmbedItemList /* Vec::Push */: EmbedItem EmbedItemList; -/* 957 */ EmbedItemList /* Vec::New */: ; -/* 958 */ EmbedItem: AnyTerm; -/* 959 */ IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; -/* 960 */ DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; -/* 961 */ DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; -/* 962 */ DescriptionGroupGroupList /* Vec::Push */: DescriptionGroup DescriptionGroupGroupList; -/* 963 */ DescriptionGroupGroupList /* Vec::New */: ; -/* 964 */ DescriptionGroupGroup: DescriptionItem; -/* 965 */ DescriptionGroupList /* Vec::Push */: Attribute DescriptionGroupList; -/* 966 */ DescriptionGroupList /* Vec::New */: ; -/* 967 */ DescriptionItem: ModuleDeclaration; -/* 968 */ DescriptionItem: InterfaceDeclaration; -/* 969 */ DescriptionItem: PackageDeclaration; -/* 970 */ DescriptionItem: ImportDeclaration; -/* 971 */ DescriptionItem: EmbedDeclaration; -/* 972 */ DescriptionItem: IncludeDeclaration; -/* 973 */ Veryl: Start VerylList /* Vec */; -/* 974 */ VerylList /* Vec::Push */: DescriptionGroup VerylList; -/* 975 */ VerylList /* Vec::New */: ; +/* 53 */ ConstTerm: /(?-u:\b)const(?-u:\b)/ : Token; +/* 54 */ DefaultTerm: /(?-u:\b)default(?-u:\b)/ : Token; +/* 55 */ ElseTerm: /(?-u:\b)else(?-u:\b)/ : Token; +/* 56 */ EmbedTerm: /(?-u:\b)embed(?-u:\b)/ : Token; +/* 57 */ EnumTerm: /(?-u:\b)enum(?-u:\b)/ : Token; +/* 58 */ ExportTerm: /(?-u:\b)export(?-u:\b)/ : Token; +/* 59 */ F32Term: /(?-u:\b)f32(?-u:\b)/ : Token; +/* 60 */ F64Term: /(?-u:\b)f64(?-u:\b)/ : Token; +/* 61 */ FinalTerm: /(?-u:\b)final(?-u:\b)/ : Token; +/* 62 */ ForTerm: /(?-u:\b)for(?-u:\b)/ : Token; +/* 63 */ FunctionTerm: /(?-u:\b)function(?-u:\b)/ : Token; +/* 64 */ I32Term: /(?-u:\b)i32(?-u:\b)/ : Token; +/* 65 */ I64Term: /(?-u:\b)i64(?-u:\b)/ : Token; +/* 66 */ IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/ : Token; +/* 67 */ IfTerm: /(?-u:\b)if(?-u:\b)/ : Token; +/* 68 */ ImportTerm: /(?-u:\b)import(?-u:\b)/ : Token; +/* 69 */ IncludeTerm: /(?-u:\b)include(?-u:\b)/ : Token; +/* 70 */ InitialTerm: /(?-u:\b)initial(?-u:\b)/ : Token; +/* 71 */ InoutTerm: /(?-u:\b)inout(?-u:\b)/ : Token; +/* 72 */ InputTerm: /(?-u:\b)input(?-u:\b)/ : Token; +/* 73 */ InsideTerm: /(?-u:\b)inside(?-u:\b)/ : Token; +/* 74 */ InstTerm: /(?-u:\b)inst(?-u:\b)/ : Token; +/* 75 */ InterfaceTerm: /(?-u:\b)interface(?-u:\b)/ : Token; +/* 76 */ InTerm: /(?-u:\b)in(?-u:\b)/ : Token; +/* 77 */ LetTerm: /(?-u:\b)let(?-u:\b)/ : Token; +/* 78 */ LocalTerm: /(?-u:\b)local(?-u:\b)/ : Token; +/* 79 */ LogicTerm: /(?-u:\b)logic(?-u:\b)/ : Token; +/* 80 */ LsbTerm: /(?-u:\b)lsb(?-u:\b)/ : Token; +/* 81 */ ModportTerm: /(?-u:\b)modport(?-u:\b)/ : Token; +/* 82 */ ModuleTerm: /(?-u:\b)module(?-u:\b)/ : Token; +/* 83 */ MsbTerm: /(?-u:\b)msb(?-u:\b)/ : Token; +/* 84 */ OutputTerm: /(?-u:\b)output(?-u:\b)/ : Token; +/* 85 */ OutsideTerm: /(?-u:\b)outside(?-u:\b)/ : Token; +/* 86 */ PackageTerm: /(?-u:\b)package(?-u:\b)/ : Token; +/* 87 */ ParamTerm: /(?-u:\b)param(?-u:\b)/ : Token; +/* 88 */ ProtoTerm: /(?-u:\b)proto(?-u:\b)/ : Token; +/* 89 */ PubTerm: /(?-u:\b)pub(?-u:\b)/ : Token; +/* 90 */ RefTerm: /(?-u:\b)ref(?-u:\b)/ : Token; +/* 91 */ RepeatTerm: /(?-u:\b)repeat(?-u:\b)/ : Token; +/* 92 */ ResetTerm: /(?-u:\b)reset(?-u:\b)/ : Token; +/* 93 */ ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/ : Token; +/* 94 */ ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/ : Token; +/* 95 */ ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/ : Token; +/* 96 */ ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/ : Token; +/* 97 */ ReturnTerm: /(?-u:\b)return(?-u:\b)/ : Token; +/* 98 */ BreakTerm: /(?-u:\b)break(?-u:\b)/ : Token; +/* 99 */ SignedTerm: /(?-u:\b)signed(?-u:\b)/ : Token; +/* 100 */ StepTerm: /(?-u:\b)step(?-u:\b)/ : Token; +/* 101 */ StringTerm: /(?-u:\b)string(?-u:\b)/ : Token; +/* 102 */ StructTerm: /(?-u:\b)struct(?-u:\b)/ : Token; +/* 103 */ SwitchTerm: /(?-u:\b)switch(?-u:\b)/ : Token; +/* 104 */ TriTerm: /(?-u:\b)tri(?-u:\b)/ : Token; +/* 105 */ TypeTerm: /(?-u:\b)type(?-u:\b)/ : Token; +/* 106 */ U32Term: /(?-u:\b)u32(?-u:\b)/ : Token; +/* 107 */ U64Term: /(?-u:\b)u64(?-u:\b)/ : Token; +/* 108 */ UnionTerm: /(?-u:\b)union(?-u:\b)/ : Token; +/* 109 */ UnsafeTerm: /(?-u:\b)unsafe(?-u:\b)/ : Token; +/* 110 */ VarTerm: /(?-u:\b)var(?-u:\b)/ : Token; +/* 111 */ DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; +/* 112 */ IdentifierTerm: /(?:r#)?[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; +/* 113 */ AnyTerm: /[^{}]*/ : Token; +/* 114 */ Comments: CommentsOpt /* Option */; +/* 115 */ CommentsOpt /* Option::Some */: CommentsTerm; +/* 116 */ CommentsOpt /* Option::None */: ; +/* 117 */ StartToken: Comments; +/* 118 */ StringLiteralToken: StringLiteralTerm : Token Comments; +/* 119 */ ExponentToken: ExponentTerm : Token Comments; +/* 120 */ FixedPointToken: FixedPointTerm : Token Comments; +/* 121 */ BasedToken: BasedTerm : Token Comments; +/* 122 */ BaseLessToken: BaseLessTerm : Token Comments; +/* 123 */ AllBitToken: AllBitTerm : Token Comments; +/* 124 */ AssignmentOperatorToken: AssignmentOperatorTerm : Token Comments; +/* 125 */ Operator01Token: Operator01Term : Token Comments; +/* 126 */ Operator02Token: Operator02Term : Token Comments; +/* 127 */ Operator03Token: Operator03Term : Token Comments; +/* 128 */ Operator04Token: Operator04Term : Token Comments; +/* 129 */ Operator05Token: Operator05Term : Token Comments; +/* 130 */ Operator06Token: Operator06Term : Token Comments; +/* 131 */ Operator07Token: Operator07Term : Token Comments; +/* 132 */ Operator08Token: Operator08Term : Token Comments; +/* 133 */ Operator09Token: Operator09Term : Token Comments; +/* 134 */ Operator10Token: Operator10Term : Token Comments; +/* 135 */ Operator11Token: Operator11Term : Token Comments; +/* 136 */ UnaryOperatorToken: UnaryOperatorTerm : Token Comments; +/* 137 */ BackQuoteToken: BackQuoteTerm : Token Comments; +/* 138 */ ColonToken: ColonTerm : Token Comments; +/* 139 */ ColonColonLAngleToken: ColonColonLAngleTerm : Token Comments; +/* 140 */ ColonColonToken: ColonColonTerm : Token Comments; +/* 141 */ CommaToken: CommaTerm : Token Comments; +/* 142 */ DotDotToken: DotDotTerm : Token Comments; +/* 143 */ DotDotEquToken: DotDotEquTerm : Token Comments; +/* 144 */ DotToken: DotTerm : Token Comments; +/* 145 */ EquToken: EquTerm : Token Comments; +/* 146 */ HashToken: HashTerm : Token Comments; +/* 147 */ QuoteLBraceToken: QuoteLBraceTerm : Token Comments; +/* 148 */ LAngleToken: LAngleTerm : Token Comments; +/* 149 */ LBraceToken: LBraceTerm : Token Comments; +/* 150 */ LBracketToken: LBracketTerm : Token Comments; +/* 151 */ LParenToken: LParenTerm : Token Comments; +/* 152 */ MinusColonToken: MinusColonTerm : Token Comments; +/* 153 */ MinusGTToken: MinusGTTerm : Token Comments; +/* 154 */ PlusColonToken: PlusColonTerm : Token Comments; +/* 155 */ RAngleToken: RAngleTerm : Token Comments; +/* 156 */ RBraceToken: RBraceTerm : Token Comments; +/* 157 */ RBracketToken: RBracketTerm : Token Comments; +/* 158 */ RParenToken: RParenTerm : Token Comments; +/* 159 */ SemicolonToken: SemicolonTerm : Token Comments; +/* 160 */ StarToken: StarTerm : Token Comments; +/* 161 */ AlwaysCombToken: AlwaysCombTerm : Token Comments; +/* 162 */ AlwaysFfToken: AlwaysFfTerm : Token Comments; +/* 163 */ AsToken: AsTerm : Token Comments; +/* 164 */ AssignToken: AssignTerm : Token Comments; +/* 165 */ BitToken: BitTerm : Token Comments; +/* 166 */ CaseToken: CaseTerm : Token Comments; +/* 167 */ ClockToken: ClockTerm : Token Comments; +/* 168 */ ClockPosedgeToken: ClockPosedgeTerm : Token Comments; +/* 169 */ ClockNegedgeToken: ClockNegedgeTerm : Token Comments; +/* 170 */ ConstToken: ConstTerm : Token Comments; +/* 171 */ DefaultToken: DefaultTerm : Token Comments; +/* 172 */ ElseToken: ElseTerm : Token Comments; +/* 173 */ EmbedToken: EmbedTerm : Token Comments; +/* 174 */ EnumToken: EnumTerm : Token Comments; +/* 175 */ ExportToken: ExportTerm : Token Comments; +/* 176 */ F32Token: F32Term : Token Comments; +/* 177 */ F64Token: F64Term : Token Comments; +/* 178 */ FinalToken: FinalTerm : Token Comments; +/* 179 */ ForToken: ForTerm : Token Comments; +/* 180 */ FunctionToken: FunctionTerm : Token Comments; +/* 181 */ I32Token: I32Term : Token Comments; +/* 182 */ I64Token: I64Term : Token Comments; +/* 183 */ IfResetToken: IfResetTerm : Token Comments; +/* 184 */ IfToken: IfTerm : Token Comments; +/* 185 */ ImportToken: ImportTerm : Token Comments; +/* 186 */ IncludeToken: IncludeTerm : Token Comments; +/* 187 */ InitialToken: InitialTerm : Token Comments; +/* 188 */ InoutToken: InoutTerm : Token Comments; +/* 189 */ InputToken: InputTerm : Token Comments; +/* 190 */ InsideToken: InsideTerm : Token Comments; +/* 191 */ InstToken: InstTerm : Token Comments; +/* 192 */ InterfaceToken: InterfaceTerm : Token Comments; +/* 193 */ InToken: InTerm : Token Comments; +/* 194 */ LetToken: LetTerm : Token Comments; +/* 195 */ LocalToken: LocalTerm : Token Comments; +/* 196 */ LogicToken: LogicTerm : Token Comments; +/* 197 */ LsbToken: LsbTerm : Token Comments; +/* 198 */ ModportToken: ModportTerm : Token Comments; +/* 199 */ ModuleToken: ModuleTerm : Token Comments; +/* 200 */ MsbToken: MsbTerm : Token Comments; +/* 201 */ OutputToken: OutputTerm : Token Comments; +/* 202 */ OutsideToken: OutsideTerm : Token Comments; +/* 203 */ PackageToken: PackageTerm : Token Comments; +/* 204 */ ParamToken: ParamTerm : Token Comments; +/* 205 */ ProtoToken: ProtoTerm : Token Comments; +/* 206 */ PubToken: PubTerm : Token Comments; +/* 207 */ RefToken: RefTerm : Token Comments; +/* 208 */ RepeatToken: RepeatTerm : Token Comments; +/* 209 */ ResetToken: ResetTerm : Token Comments; +/* 210 */ ResetAsyncHighToken: ResetAsyncHighTerm : Token Comments; +/* 211 */ ResetAsyncLowToken: ResetAsyncLowTerm : Token Comments; +/* 212 */ ResetSyncHighToken: ResetSyncHighTerm : Token Comments; +/* 213 */ ResetSyncLowToken: ResetSyncLowTerm : Token Comments; +/* 214 */ ReturnToken: ReturnTerm : Token Comments; +/* 215 */ BreakToken: BreakTerm : Token Comments; +/* 216 */ SignedToken: SignedTerm : Token Comments; +/* 217 */ StepToken: StepTerm : Token Comments; +/* 218 */ StringToken: StringTerm : Token Comments; +/* 219 */ StructToken: StructTerm : Token Comments; +/* 220 */ SwitchToken: SwitchTerm : Token Comments; +/* 221 */ TriToken: TriTerm : Token Comments; +/* 222 */ TypeToken: TypeTerm : Token Comments; +/* 223 */ U32Token: U32Term : Token Comments; +/* 224 */ U64Token: U64Term : Token Comments; +/* 225 */ UnionToken: UnionTerm : Token Comments; +/* 226 */ UnsafeToken: UnsafeTerm : Token Comments; +/* 227 */ VarToken: VarTerm : Token Comments; +/* 228 */ DollarIdentifierToken: DollarIdentifierTerm : Token Comments; +/* 229 */ IdentifierToken: IdentifierTerm : Token Comments; +/* 230 */ Start: StartToken : VerylToken; +/* 231 */ StringLiteral: StringLiteralToken : VerylToken; +/* 232 */ Exponent: ExponentToken : VerylToken; +/* 233 */ FixedPoint: FixedPointToken : VerylToken; +/* 234 */ Based: BasedToken : VerylToken; +/* 235 */ BaseLess: BaseLessToken : VerylToken; +/* 236 */ AllBit: AllBitToken : VerylToken; +/* 237 */ AssignmentOperator: AssignmentOperatorToken : VerylToken; +/* 238 */ Operator01: Operator01Token : VerylToken; +/* 239 */ Operator02: Operator02Token : VerylToken; +/* 240 */ Operator03: Operator03Token : VerylToken; +/* 241 */ Operator04: Operator04Token : VerylToken; +/* 242 */ Operator05: Operator05Token : VerylToken; +/* 243 */ Operator06: Operator06Token : VerylToken; +/* 244 */ Operator07: Operator07Token : VerylToken; +/* 245 */ Operator08: Operator08Token : VerylToken; +/* 246 */ Operator09: Operator09Token : VerylToken; +/* 247 */ Operator10: Operator10Token : VerylToken; +/* 248 */ Operator11: Operator11Token : VerylToken; +/* 249 */ UnaryOperator: UnaryOperatorToken : VerylToken; +/* 250 */ BackQuote: BackQuoteToken : VerylToken; +/* 251 */ Colon: ColonToken : VerylToken; +/* 252 */ ColonColonLAngle: ColonColonLAngleToken : VerylToken; +/* 253 */ ColonColon: ColonColonToken : VerylToken; +/* 254 */ Comma: CommaToken : VerylToken; +/* 255 */ DotDot: DotDotToken : VerylToken; +/* 256 */ DotDotEqu: DotDotEquToken : VerylToken; +/* 257 */ Dot: DotToken : VerylToken; +/* 258 */ Equ: EquToken : VerylToken; +/* 259 */ Hash: HashToken : VerylToken; +/* 260 */ QuoteLBrace: QuoteLBraceToken : VerylToken; +/* 261 */ LAngle: LAngleToken : VerylToken; +/* 262 */ LBrace: LBraceToken : VerylToken; +/* 263 */ LBracket: LBracketToken : VerylToken; +/* 264 */ LParen: LParenToken : VerylToken; +/* 265 */ MinusColon: MinusColonToken : VerylToken; +/* 266 */ MinusGT: MinusGTToken : VerylToken; +/* 267 */ PlusColon: PlusColonToken : VerylToken; +/* 268 */ RAngle: RAngleToken : VerylToken; +/* 269 */ RBrace: RBraceToken : VerylToken; +/* 270 */ RBracket: RBracketToken : VerylToken; +/* 271 */ RParen: RParenToken : VerylToken; +/* 272 */ Semicolon: SemicolonToken : VerylToken; +/* 273 */ Star: StarToken : VerylToken; +/* 274 */ AlwaysComb: AlwaysCombToken : VerylToken; +/* 275 */ AlwaysFf: AlwaysFfToken : VerylToken; +/* 276 */ As: AsToken : VerylToken; +/* 277 */ Assign: AssignToken : VerylToken; +/* 278 */ Bit: BitToken : VerylToken; +/* 279 */ Break: BreakToken : VerylToken; +/* 280 */ Case: CaseToken : VerylToken; +/* 281 */ Clock: ClockToken : VerylToken; +/* 282 */ ClockPosedge: ClockPosedgeToken : VerylToken; +/* 283 */ ClockNegedge: ClockNegedgeToken : VerylToken; +/* 284 */ Const: ConstToken : VerylToken; +/* 285 */ Defaul: DefaultToken : VerylToken; +/* 286 */ Else: ElseToken : VerylToken; +/* 287 */ Embed: EmbedToken : VerylToken; +/* 288 */ Enum: EnumToken : VerylToken; +/* 289 */ Export: ExportToken : VerylToken; +/* 290 */ F32: F32Token : VerylToken; +/* 291 */ F64: F64Token : VerylToken; +/* 292 */ Final: FinalToken : VerylToken; +/* 293 */ For: ForToken : VerylToken; +/* 294 */ Function: FunctionToken : VerylToken; +/* 295 */ I32: I32Token : VerylToken; +/* 296 */ I64: I64Token : VerylToken; +/* 297 */ If: IfToken : VerylToken; +/* 298 */ IfReset: IfResetToken : VerylToken; +/* 299 */ Import: ImportToken : VerylToken; +/* 300 */ In: InToken : VerylToken; +/* 301 */ Include: IncludeToken : VerylToken; +/* 302 */ Initial: InitialToken : VerylToken; +/* 303 */ Inout: InoutToken : VerylToken; +/* 304 */ Input: InputToken : VerylToken; +/* 305 */ Inside: InsideToken : VerylToken; +/* 306 */ Inst: InstToken : VerylToken; +/* 307 */ Interface: InterfaceToken : VerylToken; +/* 308 */ Let: LetToken : VerylToken; +/* 309 */ Local: LocalToken : VerylToken; +/* 310 */ Logic: LogicToken : VerylToken; +/* 311 */ Lsb: LsbToken : VerylToken; +/* 312 */ Modport: ModportToken : VerylToken; +/* 313 */ Module: ModuleToken : VerylToken; +/* 314 */ Msb: MsbToken : VerylToken; +/* 315 */ Output: OutputToken : VerylToken; +/* 316 */ Outside: OutsideToken : VerylToken; +/* 317 */ Package: PackageToken : VerylToken; +/* 318 */ Param: ParamToken : VerylToken; +/* 319 */ Proto: ProtoToken : VerylToken; +/* 320 */ Pub: PubToken : VerylToken; +/* 321 */ Ref: RefToken : VerylToken; +/* 322 */ Repeat: RepeatToken : VerylToken; +/* 323 */ Reset: ResetToken : VerylToken; +/* 324 */ ResetAsyncHigh: ResetAsyncHighToken : VerylToken; +/* 325 */ ResetAsyncLow: ResetAsyncLowToken : VerylToken; +/* 326 */ ResetSyncHigh: ResetSyncHighToken : VerylToken; +/* 327 */ ResetSyncLow: ResetSyncLowToken : VerylToken; +/* 328 */ Return: ReturnToken : VerylToken; +/* 329 */ Signed: SignedToken : VerylToken; +/* 330 */ Step: StepToken : VerylToken; +/* 331 */ Strin: StringToken : VerylToken; +/* 332 */ Struct: StructToken : VerylToken; +/* 333 */ Switch: SwitchToken : VerylToken; +/* 334 */ Tri: TriToken : VerylToken; +/* 335 */ Type: TypeToken : VerylToken; +/* 336 */ U32: U32Token : VerylToken; +/* 337 */ U64: U64Token : VerylToken; +/* 338 */ Union: UnionToken : VerylToken; +/* 339 */ Unsafe: UnsafeToken : VerylToken; +/* 340 */ Var: VarToken : VerylToken; +/* 341 */ DollarIdentifier: DollarIdentifierToken : VerylToken; +/* 342 */ Identifier: IdentifierToken : VerylToken; +/* 343 */ Number: IntegralNumber; +/* 344 */ Number: RealNumber; +/* 345 */ IntegralNumber: Based; +/* 346 */ IntegralNumber: BaseLess; +/* 347 */ IntegralNumber: AllBit; +/* 348 */ RealNumber: FixedPoint; +/* 349 */ RealNumber: Exponent; +/* 350 */ HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; +/* 351 */ HierarchicalIdentifierList0 /* Vec::Push */: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; +/* 352 */ HierarchicalIdentifierList0List /* Vec::Push */: Select HierarchicalIdentifierList0List; +/* 353 */ HierarchicalIdentifierList0List /* Vec::New */: ; +/* 354 */ HierarchicalIdentifierList0 /* Vec::New */: ; +/* 355 */ HierarchicalIdentifierList /* Vec::Push */: Select HierarchicalIdentifierList; +/* 356 */ HierarchicalIdentifierList /* Vec::New */: ; +/* 357 */ ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; +/* 358 */ ScopedIdentifierGroup: DollarIdentifier; +/* 359 */ ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */; +/* 360 */ ScopedIdentifierList /* Vec::Push */: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList; +/* 361 */ ScopedIdentifierList /* Vec::New */: ; +/* 362 */ ScopedIdentifierOpt0 /* Option::Some */: WithGenericArgument; +/* 363 */ ScopedIdentifierOpt0 /* Option::None */: ; +/* 364 */ ScopedIdentifierOpt /* Option::Some */: WithGenericArgument; +/* 365 */ ScopedIdentifierOpt /* Option::None */: ; +/* 366 */ ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; +/* 367 */ ExpressionIdentifierList0 /* Vec::Push */: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; +/* 368 */ ExpressionIdentifierList0List /* Vec::Push */: Select ExpressionIdentifierList0List; +/* 369 */ ExpressionIdentifierList0List /* Vec::New */: ; +/* 370 */ ExpressionIdentifierList0 /* Vec::New */: ; +/* 371 */ ExpressionIdentifierList /* Vec::Push */: Select ExpressionIdentifierList; +/* 372 */ ExpressionIdentifierList /* Vec::New */: ; +/* 373 */ Expression: Expression01 ExpressionList /* Vec */; +/* 374 */ ExpressionList /* Vec::Push */: Operator01 Expression01 ExpressionList; +/* 375 */ ExpressionList /* Vec::New */: ; +/* 376 */ Expression01: Expression02 Expression01List /* Vec */; +/* 377 */ Expression01List /* Vec::Push */: Operator02 Expression02 Expression01List; +/* 378 */ Expression01List /* Vec::New */: ; +/* 379 */ Expression02: Expression03 Expression02List /* Vec */; +/* 380 */ Expression02List /* Vec::Push */: Operator03 Expression03 Expression02List; +/* 381 */ Expression02List /* Vec::New */: ; +/* 382 */ Expression03: Expression04 Expression03List /* Vec */; +/* 383 */ Expression03List /* Vec::Push */: Operator04 Expression04 Expression03List; +/* 384 */ Expression03List /* Vec::New */: ; +/* 385 */ Expression04: Expression05 Expression04List /* Vec */; +/* 386 */ Expression04List /* Vec::Push */: Operator05 Expression05 Expression04List; +/* 387 */ Expression04List /* Vec::New */: ; +/* 388 */ Expression05: Expression06 Expression05List /* Vec */; +/* 389 */ Expression05List /* Vec::Push */: Operator06 Expression06 Expression05List; +/* 390 */ Expression05List /* Vec::New */: ; +/* 391 */ Expression06: Expression07 Expression06List /* Vec */; +/* 392 */ Expression06List /* Vec::Push */: Operator07 Expression07 Expression06List; +/* 393 */ Expression06List /* Vec::New */: ; +/* 394 */ Expression07: Expression08 Expression07List /* Vec */; +/* 395 */ Expression07List /* Vec::Push */: Operator08 Expression08 Expression07List; +/* 396 */ Expression07List /* Vec::New */: ; +/* 397 */ Expression08: Expression09 Expression08List /* Vec */; +/* 398 */ Expression08List /* Vec::Push */: Operator09 Expression09 Expression08List; +/* 399 */ Expression08List /* Vec::New */: ; +/* 400 */ Expression09: Expression10 Expression09List /* Vec */; +/* 401 */ Expression09List /* Vec::Push */: Expression09ListGroup Expression10 Expression09List; +/* 402 */ Expression09ListGroup: Operator10; +/* 403 */ Expression09ListGroup: Star; +/* 404 */ Expression09List /* Vec::New */: ; +/* 405 */ Expression10: Expression11 Expression10List /* Vec */; +/* 406 */ Expression10List /* Vec::Push */: Operator11 Expression11 Expression10List; +/* 407 */ Expression10List /* Vec::New */: ; +/* 408 */ Expression11: Expression12 Expression11Opt /* Option */; +/* 409 */ Expression11Opt /* Option::Some */: As CastingType; +/* 410 */ Expression11Opt /* Option::None */: ; +/* 411 */ Expression12: Expression12List /* Vec */ Factor; +/* 412 */ Expression12List /* Vec::Push */: Expression12ListGroup Expression12List; +/* 413 */ Expression12ListGroup: UnaryOperator; +/* 414 */ Expression12ListGroup: Operator09; +/* 415 */ Expression12ListGroup: Operator05; +/* 416 */ Expression12ListGroup: Operator03; +/* 417 */ Expression12ListGroup: Operator04; +/* 418 */ Expression12List /* Vec::New */: ; +/* 419 */ Factor: Number; +/* 420 */ Factor: ExpressionIdentifier FactorOpt /* Option */; +/* 421 */ Factor: LParen Expression RParen; +/* 422 */ Factor: LBrace ConcatenationList RBrace; +/* 423 */ Factor: QuoteLBrace ArrayLiteralList RBrace; +/* 424 */ Factor: IfExpression; +/* 425 */ Factor: CaseExpression; +/* 426 */ Factor: SwitchExpression; +/* 427 */ Factor: StringLiteral; +/* 428 */ Factor: FactorGroup; +/* 429 */ FactorGroup: Msb; +/* 430 */ FactorGroup: Lsb; +/* 431 */ Factor: InsideExpression; +/* 432 */ Factor: OutsideExpression; +/* 433 */ FactorOpt /* Option::Some */: FunctionCall; +/* 434 */ FactorOpt /* Option::None */: ; +/* 435 */ FunctionCall: LParen FunctionCallOpt /* Option */ RParen; +/* 436 */ FunctionCallOpt /* Option::Some */: ArgumentList; +/* 437 */ FunctionCallOpt /* Option::None */: ; +/* 438 */ ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; +/* 439 */ ArgumentListList /* Vec::Push */: Comma ArgumentItem ArgumentListList; +/* 440 */ ArgumentListList /* Vec::New */: ; +/* 441 */ ArgumentListOpt /* Option::Some */: Comma; +/* 442 */ ArgumentListOpt /* Option::None */: ; +/* 443 */ ArgumentItem: Expression; +/* 444 */ ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; +/* 445 */ ConcatenationListList /* Vec::Push */: Comma ConcatenationItem ConcatenationListList; +/* 446 */ ConcatenationListList /* Vec::New */: ; +/* 447 */ ConcatenationListOpt /* Option::Some */: Comma; +/* 448 */ ConcatenationListOpt /* Option::None */: ; +/* 449 */ ConcatenationItem: Expression ConcatenationItemOpt /* Option */; +/* 450 */ ConcatenationItemOpt /* Option::Some */: Repeat Expression; +/* 451 */ ConcatenationItemOpt /* Option::None */: ; +/* 452 */ ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; +/* 453 */ ArrayLiteralListList /* Vec::Push */: Comma ArrayLiteralItem ArrayLiteralListList; +/* 454 */ ArrayLiteralListList /* Vec::New */: ; +/* 455 */ ArrayLiteralListOpt /* Option::Some */: Comma; +/* 456 */ ArrayLiteralListOpt /* Option::None */: ; +/* 457 */ ArrayLiteralItem: ArrayLiteralItemGroup; +/* 458 */ ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; +/* 459 */ ArrayLiteralItemGroup: Defaul Colon Expression; +/* 460 */ ArrayLiteralItemOpt /* Option::Some */: Repeat Expression; +/* 461 */ ArrayLiteralItemOpt /* Option::None */: ; +/* 462 */ IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; +/* 463 */ IfExpressionList /* Vec::Push */: Else If Expression LBrace Expression RBrace IfExpressionList; +/* 464 */ IfExpressionList /* Vec::New */: ; +/* 465 */ CaseExpression: Case Expression LBrace CaseCondition Colon Expression Comma CaseExpressionList /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; +/* 466 */ CaseExpressionList /* Vec::Push */: CaseCondition Colon Expression Comma CaseExpressionList; +/* 467 */ CaseExpressionList /* Vec::New */: ; +/* 468 */ CaseExpressionOpt /* Option::Some */: Comma; +/* 469 */ CaseExpressionOpt /* Option::None */: ; +/* 470 */ SwitchExpression: Switch LBrace SwitchCondition Colon Expression Comma SwitchExpressionList /* Vec */ Defaul Colon Expression SwitchExpressionOpt /* Option */ RBrace; +/* 471 */ SwitchExpressionList /* Vec::Push */: SwitchCondition Colon Expression Comma SwitchExpressionList; +/* 472 */ SwitchExpressionList /* Vec::New */: ; +/* 473 */ SwitchExpressionOpt /* Option::Some */: Comma; +/* 474 */ SwitchExpressionOpt /* Option::None */: ; +/* 475 */ TypeExpression: ScalarType; +/* 476 */ TypeExpression: Type LParen Expression RParen; +/* 477 */ InsideExpression: Inside Expression LBrace RangeList RBrace; +/* 478 */ OutsideExpression: Outside Expression LBrace RangeList RBrace; +/* 479 */ RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; +/* 480 */ RangeListList /* Vec::Push */: Comma RangeItem RangeListList; +/* 481 */ RangeListList /* Vec::New */: ; +/* 482 */ RangeListOpt /* Option::Some */: Comma; +/* 483 */ RangeListOpt /* Option::None */: ; +/* 484 */ RangeItem: Range; +/* 485 */ Select: LBracket Expression SelectOpt /* Option */ RBracket; +/* 486 */ SelectOpt /* Option::Some */: SelectOperator Expression; +/* 487 */ SelectOpt /* Option::None */: ; +/* 488 */ SelectOperator: Colon; +/* 489 */ SelectOperator: PlusColon; +/* 490 */ SelectOperator: MinusColon; +/* 491 */ SelectOperator: Step; +/* 492 */ Width: LAngle Expression WidthList /* Vec */ RAngle; +/* 493 */ WidthList /* Vec::Push */: Comma Expression WidthList; +/* 494 */ WidthList /* Vec::New */: ; +/* 495 */ Array: LBracket Expression ArrayList /* Vec */ RBracket; +/* 496 */ ArrayList /* Vec::Push */: Comma Expression ArrayList; +/* 497 */ ArrayList /* Vec::New */: ; +/* 498 */ Range: Expression RangeOpt /* Option */; +/* 499 */ RangeOpt /* Option::Some */: RangeOperator Expression; +/* 500 */ RangeOpt /* Option::None */: ; +/* 501 */ RangeOperator: DotDot; +/* 502 */ RangeOperator: DotDotEqu; +/* 503 */ FixedType: U32; +/* 504 */ FixedType: U64; +/* 505 */ FixedType: I32; +/* 506 */ FixedType: I64; +/* 507 */ FixedType: F32; +/* 508 */ FixedType: F64; +/* 509 */ FixedType: Strin; +/* 510 */ VariableType: Clock; +/* 511 */ VariableType: ClockPosedge; +/* 512 */ VariableType: ClockNegedge; +/* 513 */ VariableType: Reset; +/* 514 */ VariableType: ResetAsyncHigh; +/* 515 */ VariableType: ResetAsyncLow; +/* 516 */ VariableType: ResetSyncHigh; +/* 517 */ VariableType: ResetSyncLow; +/* 518 */ VariableType: Logic; +/* 519 */ VariableType: Bit; +/* 520 */ VariableType: ScopedIdentifier; +/* 521 */ TypeModifier: Tri; +/* 522 */ TypeModifier: Signed; +/* 523 */ ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; +/* 524 */ ScalarTypeGroup: VariableType ScalarTypeOpt /* Option */; +/* 525 */ ScalarTypeGroup: FixedType; +/* 526 */ ScalarTypeList /* Vec::Push */: TypeModifier ScalarTypeList; +/* 527 */ ScalarTypeList /* Vec::New */: ; +/* 528 */ ScalarTypeOpt /* Option::Some */: Width; +/* 529 */ ScalarTypeOpt /* Option::None */: ; +/* 530 */ ArrayType: ScalarType ArrayTypeOpt /* Option */; +/* 531 */ ArrayTypeOpt /* Option::Some */: Array; +/* 532 */ ArrayTypeOpt /* Option::None */: ; +/* 533 */ CastingType: U32; +/* 534 */ CastingType: U64; +/* 535 */ CastingType: I32; +/* 536 */ CastingType: I64; +/* 537 */ CastingType: F32; +/* 538 */ CastingType: F64; +/* 539 */ CastingType: Clock; +/* 540 */ CastingType: ClockPosedge; +/* 541 */ CastingType: ClockNegedge; +/* 542 */ CastingType: Reset; +/* 543 */ CastingType: ResetAsyncHigh; +/* 544 */ CastingType: ResetAsyncLow; +/* 545 */ CastingType: ResetSyncHigh; +/* 546 */ CastingType: ResetSyncLow; +/* 547 */ CastingType: ScopedIdentifier; +/* 548 */ ClockDomain: BackQuote Identifier; +/* 549 */ Statement: LetStatement; +/* 550 */ Statement: IdentifierStatement; +/* 551 */ Statement: IfStatement; +/* 552 */ Statement: IfResetStatement; +/* 553 */ Statement: ReturnStatement; +/* 554 */ Statement: BreakStatement; +/* 555 */ Statement: ForStatement; +/* 556 */ Statement: CaseStatement; +/* 557 */ Statement: SwitchStatement; +/* 558 */ LetStatement: Let Identifier Colon LetStatementOpt /* Option */ ArrayType Equ Expression Semicolon; +/* 559 */ LetStatementOpt /* Option::Some */: ClockDomain; +/* 560 */ LetStatementOpt /* Option::None */: ; +/* 561 */ IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; +/* 562 */ IdentifierStatementGroup: FunctionCall; +/* 563 */ IdentifierStatementGroup: Assignment; +/* 564 */ Assignment: AssignmentGroup Expression; +/* 565 */ AssignmentGroup: Equ; +/* 566 */ AssignmentGroup: AssignmentOperator; +/* 567 */ IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; +/* 568 */ IfStatementList0 /* Vec::Push */: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; +/* 569 */ IfStatementList0List /* Vec::Push */: Statement IfStatementList0List; +/* 570 */ IfStatementList0List /* Vec::New */: ; +/* 571 */ IfStatementList0 /* Vec::New */: ; +/* 572 */ IfStatementList /* Vec::Push */: Statement IfStatementList; +/* 573 */ IfStatementList /* Vec::New */: ; +/* 574 */ IfStatementOpt /* Option::Some */: Else LBrace IfStatementOptList /* Vec */ RBrace; +/* 575 */ IfStatementOptList /* Vec::Push */: Statement IfStatementOptList; +/* 576 */ IfStatementOptList /* Vec::New */: ; +/* 577 */ IfStatementOpt /* Option::None */: ; +/* 578 */ IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; +/* 579 */ IfResetStatementList0 /* Vec::Push */: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; +/* 580 */ IfResetStatementList0List /* Vec::Push */: Statement IfResetStatementList0List; +/* 581 */ IfResetStatementList0List /* Vec::New */: ; +/* 582 */ IfResetStatementList0 /* Vec::New */: ; +/* 583 */ IfResetStatementList /* Vec::Push */: Statement IfResetStatementList; +/* 584 */ IfResetStatementList /* Vec::New */: ; +/* 585 */ IfResetStatementOpt /* Option::Some */: Else LBrace IfResetStatementOptList /* Vec */ RBrace; +/* 586 */ IfResetStatementOptList /* Vec::Push */: Statement IfResetStatementOptList; +/* 587 */ IfResetStatementOptList /* Vec::New */: ; +/* 588 */ IfResetStatementOpt /* Option::None */: ; +/* 589 */ ReturnStatement: Return Expression Semicolon; +/* 590 */ BreakStatement: Break Semicolon; +/* 591 */ ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; +/* 592 */ ForStatementList /* Vec::Push */: Statement ForStatementList; +/* 593 */ ForStatementList /* Vec::New */: ; +/* 594 */ ForStatementOpt /* Option::Some */: Step AssignmentOperator Expression; +/* 595 */ ForStatementOpt /* Option::None */: ; +/* 596 */ CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; +/* 597 */ CaseStatementList /* Vec::Push */: CaseItem CaseStatementList; +/* 598 */ CaseStatementList /* Vec::New */: ; +/* 599 */ CaseItem: CaseItemGroup Colon CaseItemGroup0; +/* 600 */ CaseItemGroup0: Statement; +/* 601 */ CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; +/* 602 */ CaseItemGroup0List /* Vec::Push */: Statement CaseItemGroup0List; +/* 603 */ CaseItemGroup0List /* Vec::New */: ; +/* 604 */ CaseItemGroup: CaseCondition; +/* 605 */ CaseItemGroup: Defaul; +/* 606 */ CaseCondition: RangeItem CaseConditionList /* Vec */; +/* 607 */ CaseConditionList /* Vec::Push */: Comma RangeItem CaseConditionList; +/* 608 */ CaseConditionList /* Vec::New */: ; +/* 609 */ SwitchStatement: Switch LBrace SwitchStatementList /* Vec */ RBrace; +/* 610 */ SwitchStatementList /* Vec::Push */: SwitchItem SwitchStatementList; +/* 611 */ SwitchStatementList /* Vec::New */: ; +/* 612 */ SwitchItem: SwitchItemGroup Colon SwitchItemGroup0; +/* 613 */ SwitchItemGroup0: Statement; +/* 614 */ SwitchItemGroup0: LBrace SwitchItemGroup0List /* Vec */ RBrace; +/* 615 */ SwitchItemGroup0List /* Vec::Push */: Statement SwitchItemGroup0List; +/* 616 */ SwitchItemGroup0List /* Vec::New */: ; +/* 617 */ SwitchItemGroup: SwitchCondition; +/* 618 */ SwitchItemGroup: Defaul; +/* 619 */ SwitchCondition: Expression SwitchConditionList /* Vec */; +/* 620 */ SwitchConditionList /* Vec::Push */: Comma Expression SwitchConditionList; +/* 621 */ SwitchConditionList /* Vec::New */: ; +/* 622 */ Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; +/* 623 */ AttributeOpt /* Option::Some */: LParen AttributeList RParen; +/* 624 */ AttributeOpt /* Option::None */: ; +/* 625 */ AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; +/* 626 */ AttributeListList /* Vec::Push */: Comma AttributeItem AttributeListList; +/* 627 */ AttributeListList /* Vec::New */: ; +/* 628 */ AttributeListOpt /* Option::Some */: Comma; +/* 629 */ AttributeListOpt /* Option::None */: ; +/* 630 */ AttributeItem: Identifier; +/* 631 */ AttributeItem: StringLiteral; +/* 632 */ LetDeclaration: Let Identifier Colon LetDeclarationOpt /* Option */ ArrayType Equ Expression Semicolon; +/* 633 */ LetDeclarationOpt /* Option::Some */: ClockDomain; +/* 634 */ LetDeclarationOpt /* Option::None */: ; +/* 635 */ VarDeclaration: Var Identifier Colon VarDeclarationOpt /* Option */ ArrayType Semicolon; +/* 636 */ VarDeclarationOpt /* Option::Some */: ClockDomain; +/* 637 */ VarDeclarationOpt /* Option::None */: ; +/* 638 */ LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; +/* 639 */ LocalDeclarationGroup: ArrayType Equ Expression; +/* 640 */ LocalDeclarationGroup: Type Equ TypeExpression; +/* 641 */ TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; +/* 642 */ AlwaysFfDeclaration: AlwaysFf AlwaysFfDeclarationOpt /* Option */ LBrace AlwaysFfDeclarationList /* Vec */ RBrace; +/* 643 */ AlwaysFfDeclarationList /* Vec::Push */: Statement AlwaysFfDeclarationList; +/* 644 */ AlwaysFfDeclarationList /* Vec::New */: ; +/* 645 */ AlwaysFfDeclarationOpt /* Option::Some */: AlwayfFfEventList; +/* 646 */ AlwaysFfDeclarationOpt /* Option::None */: ; +/* 647 */ AlwayfFfEventList: LParen AlwaysFfClock AlwayfFfEventListOpt /* Option */ RParen; +/* 648 */ AlwayfFfEventListOpt /* Option::Some */: Comma AlwaysFfReset; +/* 649 */ AlwayfFfEventListOpt /* Option::None */: ; +/* 650 */ AlwaysFfClock: HierarchicalIdentifier; +/* 651 */ AlwaysFfReset: HierarchicalIdentifier; +/* 652 */ AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; +/* 653 */ AlwaysCombDeclarationList /* Vec::Push */: Statement AlwaysCombDeclarationList; +/* 654 */ AlwaysCombDeclarationList /* Vec::New */: ; +/* 655 */ AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; +/* 656 */ ModportDeclaration: Modport Identifier LBrace ModportList RBrace; +/* 657 */ ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; +/* 658 */ ModportListList /* Vec::Push */: Comma ModportGroup ModportListList; +/* 659 */ ModportListList /* Vec::New */: ; +/* 660 */ ModportListOpt /* Option::Some */: Comma; +/* 661 */ ModportListOpt /* Option::None */: ; +/* 662 */ ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; +/* 663 */ ModportGroupGroup: LBrace ModportList RBrace; +/* 664 */ ModportGroupGroup: ModportItem; +/* 665 */ ModportGroupList /* Vec::Push */: Attribute ModportGroupList; +/* 666 */ ModportGroupList /* Vec::New */: ; +/* 667 */ ModportItem: Identifier Colon Direction; +/* 668 */ EnumDeclaration: Enum Identifier EnumDeclarationOpt /* Option */ LBrace EnumList RBrace; +/* 669 */ EnumDeclarationOpt /* Option::Some */: Colon ScalarType; +/* 670 */ EnumDeclarationOpt /* Option::None */: ; +/* 671 */ EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; +/* 672 */ EnumListList /* Vec::Push */: Comma EnumGroup EnumListList; +/* 673 */ EnumListList /* Vec::New */: ; +/* 674 */ EnumListOpt /* Option::Some */: Comma; +/* 675 */ EnumListOpt /* Option::None */: ; +/* 676 */ EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; +/* 677 */ EnumGroupGroup: LBrace EnumList RBrace; +/* 678 */ EnumGroupGroup: EnumItem; +/* 679 */ EnumGroupList /* Vec::Push */: Attribute EnumGroupList; +/* 680 */ EnumGroupList /* Vec::New */: ; +/* 681 */ EnumItem: Identifier EnumItemOpt /* Option */; +/* 682 */ EnumItemOpt /* Option::Some */: Equ Expression; +/* 683 */ EnumItemOpt /* Option::None */: ; +/* 684 */ StructUnion: Struct; +/* 685 */ StructUnion: Union; +/* 686 */ StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace; +/* 687 */ StructUnionDeclarationOpt /* Option::Some */: WithGenericParameter; +/* 688 */ StructUnionDeclarationOpt /* Option::None */: ; +/* 689 */ StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; +/* 690 */ StructUnionListList /* Vec::Push */: Comma StructUnionGroup StructUnionListList; +/* 691 */ StructUnionListList /* Vec::New */: ; +/* 692 */ StructUnionListOpt /* Option::Some */: Comma; +/* 693 */ StructUnionListOpt /* Option::None */: ; +/* 694 */ StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; +/* 695 */ StructUnionGroupGroup: LBrace StructUnionList RBrace; +/* 696 */ StructUnionGroupGroup: StructUnionItem; +/* 697 */ StructUnionGroupList /* Vec::Push */: Attribute StructUnionGroupList; +/* 698 */ StructUnionGroupList /* Vec::New */: ; +/* 699 */ StructUnionItem: Identifier Colon ScalarType; +/* 700 */ InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; +/* 701 */ InitialDeclarationList /* Vec::Push */: Statement InitialDeclarationList; +/* 702 */ InitialDeclarationList /* Vec::New */: ; +/* 703 */ FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; +/* 704 */ FinalDeclarationList /* Vec::Push */: Statement FinalDeclarationList; +/* 705 */ FinalDeclarationList /* Vec::New */: ; +/* 706 */ InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; +/* 707 */ InstDeclarationOpt1 /* Option::Some */: LParen InstDeclarationOpt2 /* Option */ RParen; +/* 708 */ InstDeclarationOpt2 /* Option::Some */: InstPortList; +/* 709 */ InstDeclarationOpt2 /* Option::None */: ; +/* 710 */ InstDeclarationOpt1 /* Option::None */: ; +/* 711 */ InstDeclarationOpt0 /* Option::Some */: InstParameter; +/* 712 */ InstDeclarationOpt0 /* Option::None */: ; +/* 713 */ InstDeclarationOpt /* Option::Some */: Array; +/* 714 */ InstDeclarationOpt /* Option::None */: ; +/* 715 */ InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; +/* 716 */ InstParameterOpt /* Option::Some */: InstParameterList; +/* 717 */ InstParameterOpt /* Option::None */: ; +/* 718 */ InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; +/* 719 */ InstParameterListList /* Vec::Push */: Comma InstParameterGroup InstParameterListList; +/* 720 */ InstParameterListList /* Vec::New */: ; +/* 721 */ InstParameterListOpt /* Option::Some */: Comma; +/* 722 */ InstParameterListOpt /* Option::None */: ; +/* 723 */ InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; +/* 724 */ InstParameterGroupGroup: LBrace InstParameterList RBrace; +/* 725 */ InstParameterGroupGroup: InstParameterItem; +/* 726 */ InstParameterGroupList /* Vec::Push */: Attribute InstParameterGroupList; +/* 727 */ InstParameterGroupList /* Vec::New */: ; +/* 728 */ InstParameterItem: Identifier InstParameterItemOpt /* Option */; +/* 729 */ InstParameterItemOpt /* Option::Some */: Colon Expression; +/* 730 */ InstParameterItemOpt /* Option::None */: ; +/* 731 */ InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; +/* 732 */ InstPortListList /* Vec::Push */: Comma InstPortGroup InstPortListList; +/* 733 */ InstPortListList /* Vec::New */: ; +/* 734 */ InstPortListOpt /* Option::Some */: Comma; +/* 735 */ InstPortListOpt /* Option::None */: ; +/* 736 */ InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; +/* 737 */ InstPortGroupGroup: LBrace InstPortList RBrace; +/* 738 */ InstPortGroupGroup: InstPortItem; +/* 739 */ InstPortGroupList /* Vec::Push */: Attribute InstPortGroupList; +/* 740 */ InstPortGroupList /* Vec::New */: ; +/* 741 */ InstPortItem: Identifier InstPortItemOpt /* Option */; +/* 742 */ InstPortItemOpt /* Option::Some */: Colon Expression; +/* 743 */ InstPortItemOpt /* Option::None */: ; +/* 744 */ WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; +/* 745 */ WithParameterOpt /* Option::Some */: WithParameterList; +/* 746 */ WithParameterOpt /* Option::None */: ; +/* 747 */ WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; +/* 748 */ WithParameterListList /* Vec::Push */: Comma WithParameterGroup WithParameterListList; +/* 749 */ WithParameterListList /* Vec::New */: ; +/* 750 */ WithParameterListOpt /* Option::Some */: Comma; +/* 751 */ WithParameterListOpt /* Option::None */: ; +/* 752 */ WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; +/* 753 */ WithParameterGroupGroup: LBrace WithParameterList RBrace; +/* 754 */ WithParameterGroupGroup: WithParameterItem; +/* 755 */ WithParameterGroupList /* Vec::Push */: Attribute WithParameterGroupList; +/* 756 */ WithParameterGroupList /* Vec::New */: ; +/* 757 */ WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; +/* 758 */ WithParameterItemGroup0: ArrayType Equ Expression; +/* 759 */ WithParameterItemGroup0: Type Equ TypeExpression; +/* 760 */ WithParameterItemGroup: Param; +/* 761 */ WithParameterItemGroup: Local; +/* 762 */ GenericBound: Const; +/* 763 */ GenericBound: Type; +/* 764 */ GenericBound: ScopedIdentifier; +/* 765 */ WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; +/* 766 */ WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */; +/* 767 */ WithGenericParameterListList /* Vec::Push */: Comma WithGenericParameterItem WithGenericParameterListList; +/* 768 */ WithGenericParameterListList /* Vec::New */: ; +/* 769 */ WithGenericParameterListOpt /* Option::Some */: Comma; +/* 770 */ WithGenericParameterListOpt /* Option::None */: ; +/* 771 */ WithGenericParameterItem: Identifier Colon GenericBound WithGenericParameterItemOpt /* Option */; +/* 772 */ WithGenericParameterItemOpt /* Option::Some */: Equ WithGenericArgumentItem; +/* 773 */ WithGenericParameterItemOpt /* Option::None */: ; +/* 774 */ WithGenericArgument: ColonColonLAngle %push(Generic) WithGenericArgumentOpt /* Option */ RAngle %pop(); +/* 775 */ WithGenericArgumentOpt /* Option::Some */: WithGenericArgumentList; +/* 776 */ WithGenericArgumentOpt /* Option::None */: ; +/* 777 */ WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */; +/* 778 */ WithGenericArgumentListList /* Vec::Push */: Comma WithGenericArgumentItem WithGenericArgumentListList; +/* 779 */ WithGenericArgumentListList /* Vec::New */: ; +/* 780 */ WithGenericArgumentListOpt /* Option::Some */: Comma; +/* 781 */ WithGenericArgumentListOpt /* Option::None */: ; +/* 782 */ WithGenericArgumentItem: ScopedIdentifier; +/* 783 */ WithGenericArgumentItem: Number; +/* 784 */ PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; +/* 785 */ PortDeclarationOpt /* Option::Some */: PortDeclarationList; +/* 786 */ PortDeclarationOpt /* Option::None */: ; +/* 787 */ PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; +/* 788 */ PortDeclarationListList /* Vec::Push */: Comma PortDeclarationGroup PortDeclarationListList; +/* 789 */ PortDeclarationListList /* Vec::New */: ; +/* 790 */ PortDeclarationListOpt /* Option::Some */: Comma; +/* 791 */ PortDeclarationListOpt /* Option::None */: ; +/* 792 */ PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; +/* 793 */ PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; +/* 794 */ PortDeclarationGroupGroup: PortDeclarationItem; +/* 795 */ PortDeclarationGroupList /* Vec::Push */: Attribute PortDeclarationGroupList; +/* 796 */ PortDeclarationGroupList /* Vec::New */: ; +/* 797 */ PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; +/* 798 */ PortDeclarationItemGroup: PortTypeConcrete; +/* 799 */ PortDeclarationItemGroup: PortTypeAbstract; +/* 800 */ PortTypeConcrete: Direction PortTypeConcreteOpt /* Option */ ArrayType; +/* 801 */ PortTypeConcreteOpt /* Option::Some */: ClockDomain; +/* 802 */ PortTypeConcreteOpt /* Option::None */: ; +/* 803 */ PortTypeAbstract: PortTypeAbstractOpt /* Option */ Interface PortTypeAbstractOpt0 /* Option */; +/* 804 */ PortTypeAbstractOpt0 /* Option::Some */: Array; +/* 805 */ PortTypeAbstractOpt0 /* Option::None */: ; +/* 806 */ PortTypeAbstractOpt /* Option::Some */: ClockDomain; +/* 807 */ PortTypeAbstractOpt /* Option::None */: ; +/* 808 */ Direction: Input; +/* 809 */ Direction: Output; +/* 810 */ Direction: Inout; +/* 811 */ Direction: Ref; +/* 812 */ Direction: Modport; +/* 813 */ Direction: Import; +/* 814 */ FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; +/* 815 */ FunctionDeclarationList /* Vec::Push */: FunctionItem FunctionDeclarationList; +/* 816 */ FunctionDeclarationList /* Vec::New */: ; +/* 817 */ FunctionDeclarationOpt1 /* Option::Some */: MinusGT ScalarType; +/* 818 */ FunctionDeclarationOpt1 /* Option::None */: ; +/* 819 */ FunctionDeclarationOpt0 /* Option::Some */: PortDeclaration; +/* 820 */ FunctionDeclarationOpt0 /* Option::None */: ; +/* 821 */ FunctionDeclarationOpt /* Option::Some */: WithGenericParameter; +/* 822 */ FunctionDeclarationOpt /* Option::None */: ; +/* 823 */ FunctionItem: VarDeclaration; +/* 824 */ FunctionItem: Statement; +/* 825 */ ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; +/* 826 */ ImportDeclarationOpt /* Option::Some */: ColonColon Star; +/* 827 */ ImportDeclarationOpt /* Option::None */: ; +/* 828 */ ExportDeclaration: Export ExportDeclarationGroup Semicolon; +/* 829 */ ExportDeclarationGroup: Star; +/* 830 */ ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; +/* 831 */ ExportDeclarationOpt /* Option::Some */: ColonColon Star; +/* 832 */ ExportDeclarationOpt /* Option::None */: ; +/* 833 */ UnsafeBlock: Unsafe LParen Identifier RParen LBrace UnsafeBlockList /* Vec */ RBrace; +/* 834 */ UnsafeBlockList /* Vec::Push */: ModuleGroup UnsafeBlockList; +/* 835 */ UnsafeBlockList /* Vec::New */: ; +/* 836 */ ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ ModuleDeclarationOpt3 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; +/* 837 */ ModuleDeclarationList /* Vec::Push */: ModuleGroup ModuleDeclarationList; +/* 838 */ ModuleDeclarationList /* Vec::New */: ; +/* 839 */ ModuleDeclarationOpt3 /* Option::Some */: PortDeclaration; +/* 840 */ ModuleDeclarationOpt3 /* Option::None */: ; +/* 841 */ ModuleDeclarationOpt2 /* Option::Some */: WithParameter; +/* 842 */ ModuleDeclarationOpt2 /* Option::None */: ; +/* 843 */ ModuleDeclarationOpt1 /* Option::Some */: For ScopedIdentifier; +/* 844 */ ModuleDeclarationOpt1 /* Option::None */: ; +/* 845 */ ModuleDeclarationOpt0 /* Option::Some */: WithGenericParameter; +/* 846 */ ModuleDeclarationOpt0 /* Option::None */: ; +/* 847 */ ModuleDeclarationOpt /* Option::Some */: Pub; +/* 848 */ ModuleDeclarationOpt /* Option::None */: ; +/* 849 */ ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; +/* 850 */ ModuleIfDeclarationList /* Vec::Push */: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; +/* 851 */ ModuleIfDeclarationList /* Vec::New */: ; +/* 852 */ ModuleIfDeclarationOpt /* Option::Some */: Else ModuleOptionalNamedBlock; +/* 853 */ ModuleIfDeclarationOpt /* Option::None */: ; +/* 854 */ ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; +/* 855 */ ModuleForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; +/* 856 */ ModuleForDeclarationOpt /* Option::None */: ; +/* 857 */ ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; +/* 858 */ ModuleNamedBlockList /* Vec::Push */: ModuleGroup ModuleNamedBlockList; +/* 859 */ ModuleNamedBlockList /* Vec::New */: ; +/* 860 */ ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; +/* 861 */ ModuleOptionalNamedBlockList /* Vec::Push */: ModuleGroup ModuleOptionalNamedBlockList; +/* 862 */ ModuleOptionalNamedBlockList /* Vec::New */: ; +/* 863 */ ModuleOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; +/* 864 */ ModuleOptionalNamedBlockOpt /* Option::None */: ; +/* 865 */ ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; +/* 866 */ ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; +/* 867 */ ModuleGroupGroupList /* Vec::Push */: ModuleGroup ModuleGroupGroupList; +/* 868 */ ModuleGroupGroupList /* Vec::New */: ; +/* 869 */ ModuleGroupGroup: ModuleItem; +/* 870 */ ModuleGroupList /* Vec::Push */: Attribute ModuleGroupList; +/* 871 */ ModuleGroupList /* Vec::New */: ; +/* 872 */ ModuleItem: LetDeclaration; +/* 873 */ ModuleItem: VarDeclaration; +/* 874 */ ModuleItem: InstDeclaration; +/* 875 */ ModuleItem: TypeDefDeclaration; +/* 876 */ ModuleItem: LocalDeclaration; +/* 877 */ ModuleItem: AlwaysFfDeclaration; +/* 878 */ ModuleItem: AlwaysCombDeclaration; +/* 879 */ ModuleItem: AssignDeclaration; +/* 880 */ ModuleItem: FunctionDeclaration; +/* 881 */ ModuleItem: ModuleIfDeclaration; +/* 882 */ ModuleItem: ModuleForDeclaration; +/* 883 */ ModuleItem: EnumDeclaration; +/* 884 */ ModuleItem: StructUnionDeclaration; +/* 885 */ ModuleItem: ModuleNamedBlock; +/* 886 */ ModuleItem: ImportDeclaration; +/* 887 */ ModuleItem: InitialDeclaration; +/* 888 */ ModuleItem: FinalDeclaration; +/* 889 */ ModuleItem: UnsafeBlock; +/* 890 */ InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; +/* 891 */ InterfaceDeclarationList /* Vec::Push */: InterfaceGroup InterfaceDeclarationList; +/* 892 */ InterfaceDeclarationList /* Vec::New */: ; +/* 893 */ InterfaceDeclarationOpt1 /* Option::Some */: WithParameter; +/* 894 */ InterfaceDeclarationOpt1 /* Option::None */: ; +/* 895 */ InterfaceDeclarationOpt0 /* Option::Some */: WithGenericParameter; +/* 896 */ InterfaceDeclarationOpt0 /* Option::None */: ; +/* 897 */ InterfaceDeclarationOpt /* Option::Some */: Pub; +/* 898 */ InterfaceDeclarationOpt /* Option::None */: ; +/* 899 */ InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; +/* 900 */ InterfaceIfDeclarationList /* Vec::Push */: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; +/* 901 */ InterfaceIfDeclarationList /* Vec::New */: ; +/* 902 */ InterfaceIfDeclarationOpt /* Option::Some */: Else InterfaceOptionalNamedBlock; +/* 903 */ InterfaceIfDeclarationOpt /* Option::None */: ; +/* 904 */ InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; +/* 905 */ InterfaceForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; +/* 906 */ InterfaceForDeclarationOpt /* Option::None */: ; +/* 907 */ InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; +/* 908 */ InterfaceNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceNamedBlockList; +/* 909 */ InterfaceNamedBlockList /* Vec::New */: ; +/* 910 */ InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; +/* 911 */ InterfaceOptionalNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceOptionalNamedBlockList; +/* 912 */ InterfaceOptionalNamedBlockList /* Vec::New */: ; +/* 913 */ InterfaceOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; +/* 914 */ InterfaceOptionalNamedBlockOpt /* Option::None */: ; +/* 915 */ InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; +/* 916 */ InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; +/* 917 */ InterfaceGroupGroupList /* Vec::Push */: InterfaceGroup InterfaceGroupGroupList; +/* 918 */ InterfaceGroupGroupList /* Vec::New */: ; +/* 919 */ InterfaceGroupGroup: InterfaceItem; +/* 920 */ InterfaceGroupList /* Vec::Push */: Attribute InterfaceGroupList; +/* 921 */ InterfaceGroupList /* Vec::New */: ; +/* 922 */ InterfaceItem: LetDeclaration; +/* 923 */ InterfaceItem: VarDeclaration; +/* 924 */ InterfaceItem: LocalDeclaration; +/* 925 */ InterfaceItem: ModportDeclaration; +/* 926 */ InterfaceItem: InterfaceIfDeclaration; +/* 927 */ InterfaceItem: InterfaceForDeclaration; +/* 928 */ InterfaceItem: TypeDefDeclaration; +/* 929 */ InterfaceItem: EnumDeclaration; +/* 930 */ InterfaceItem: StructUnionDeclaration; +/* 931 */ InterfaceItem: InterfaceNamedBlock; +/* 932 */ InterfaceItem: FunctionDeclaration; +/* 933 */ InterfaceItem: ImportDeclaration; +/* 934 */ InterfaceItem: InitialDeclaration; +/* 935 */ InterfaceItem: FinalDeclaration; +/* 936 */ PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace; +/* 937 */ PackageDeclarationList /* Vec::Push */: PackageGroup PackageDeclarationList; +/* 938 */ PackageDeclarationList /* Vec::New */: ; +/* 939 */ PackageDeclarationOpt0 /* Option::Some */: WithGenericParameter; +/* 940 */ PackageDeclarationOpt0 /* Option::None */: ; +/* 941 */ PackageDeclarationOpt /* Option::Some */: Pub; +/* 942 */ PackageDeclarationOpt /* Option::None */: ; +/* 943 */ PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; +/* 944 */ PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; +/* 945 */ PackageGroupGroupList /* Vec::Push */: PackageGroup PackageGroupGroupList; +/* 946 */ PackageGroupGroupList /* Vec::New */: ; +/* 947 */ PackageGroupGroup: PackageItem; +/* 948 */ PackageGroupList /* Vec::Push */: Attribute PackageGroupList; +/* 949 */ PackageGroupList /* Vec::New */: ; +/* 950 */ PackageItem: VarDeclaration; +/* 951 */ PackageItem: LocalDeclaration; +/* 952 */ PackageItem: TypeDefDeclaration; +/* 953 */ PackageItem: EnumDeclaration; +/* 954 */ PackageItem: StructUnionDeclaration; +/* 955 */ PackageItem: FunctionDeclaration; +/* 956 */ PackageItem: ImportDeclaration; +/* 957 */ PackageItem: ExportDeclaration; +/* 958 */ PackageItem: InitialDeclaration; +/* 959 */ PackageItem: FinalDeclaration; +/* 960 */ ProtoModuleDeclaration: ProtoModuleDeclarationOpt /* Option */ Proto Module Identifier ProtoModuleDeclarationOpt0 /* Option */ ProtoModuleDeclarationOpt1 /* Option */ Semicolon; +/* 961 */ ProtoModuleDeclarationOpt1 /* Option::Some */: PortDeclaration; +/* 962 */ ProtoModuleDeclarationOpt1 /* Option::None */: ; +/* 963 */ ProtoModuleDeclarationOpt0 /* Option::Some */: WithParameter; +/* 964 */ ProtoModuleDeclarationOpt0 /* Option::None */: ; +/* 965 */ ProtoModuleDeclarationOpt /* Option::Some */: Pub; +/* 966 */ ProtoModuleDeclarationOpt /* Option::None */: ; +/* 967 */ EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; +/* 968 */ EmbedContent: EmbedContentToken : VerylToken; +/* 969 */ EmbedContentToken: LBraceTerm %push(Embed) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm %pop() Comments; +/* 970 */ EmbedContentTokenList /* Vec::Push */: EmbedItem EmbedContentTokenList; +/* 971 */ EmbedContentTokenList /* Vec::New */: ; +/* 972 */ EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; +/* 973 */ EmbedItemList /* Vec::Push */: EmbedItem EmbedItemList; +/* 974 */ EmbedItemList /* Vec::New */: ; +/* 975 */ EmbedItem: AnyTerm; +/* 976 */ IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; +/* 977 */ DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; +/* 978 */ DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; +/* 979 */ DescriptionGroupGroupList /* Vec::Push */: DescriptionGroup DescriptionGroupGroupList; +/* 980 */ DescriptionGroupGroupList /* Vec::New */: ; +/* 981 */ DescriptionGroupGroup: DescriptionItem; +/* 982 */ DescriptionGroupList /* Vec::Push */: Attribute DescriptionGroupList; +/* 983 */ DescriptionGroupList /* Vec::New */: ; +/* 984 */ DescriptionItem: ModuleDeclaration; +/* 985 */ DescriptionItem: InterfaceDeclaration; +/* 986 */ DescriptionItem: PackageDeclaration; +/* 987 */ DescriptionItem: ProtoModuleDeclaration; +/* 988 */ DescriptionItem: ImportDeclaration; +/* 989 */ DescriptionItem: EmbedDeclaration; +/* 990 */ DescriptionItem: IncludeDeclaration; +/* 991 */ Veryl: Start VerylList /* Vec */; +/* 992 */ VerylList /* Vec::Push */: DescriptionGroup VerylList; +/* 993 */ VerylList /* Vec::New */: ; diff --git a/crates/parser/src/generated/veryl_grammar_trait.rs b/crates/parser/src/generated/veryl_grammar_trait.rs index d24c297a..03ad3244 100644 --- a/crates/parser/src/generated/veryl_grammar_trait.rs +++ b/crates/parser/src/generated/veryl_grammar_trait.rs @@ -285,6 +285,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ConstTerm' + fn const_term(&mut self, _arg: &ConstTerm) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'DefaultTerm' fn default_term(&mut self, _arg: &DefaultTerm) -> Result<()> { Ok(()) @@ -455,6 +460,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ProtoTerm' + fn proto_term(&mut self, _arg: &ProtoTerm) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'PubTerm' fn pub_term(&mut self, _arg: &PubTerm) -> Result<()> { Ok(()) @@ -850,6 +860,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ConstToken' + fn const_token(&mut self, _arg: &ConstToken) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'DefaultToken' fn default_token(&mut self, _arg: &DefaultToken) -> Result<()> { Ok(()) @@ -1020,6 +1035,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ProtoToken' + fn proto_token(&mut self, _arg: &ProtoToken) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'PubToken' fn pub_token(&mut self, _arg: &PubToken) -> Result<()> { Ok(()) @@ -1410,6 +1430,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'Const' + fn r#const(&mut self, _arg: &Const) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'Defaul' fn defaul(&mut self, _arg: &Defaul) -> Result<()> { Ok(()) @@ -1580,6 +1605,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'Proto' + fn proto(&mut self, _arg: &Proto) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'Pub' fn r#pub(&mut self, _arg: &Pub) -> Result<()> { Ok(()) @@ -2210,6 +2240,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'GenericBound' + fn generic_bound(&mut self, _arg: &GenericBound) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'WithGenericParameter' fn with_generic_parameter(&mut self, _arg: &WithGenericParameter) -> Result<()> { Ok(()) @@ -2385,6 +2420,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ProtoModuleDeclaration' + fn proto_module_declaration(&mut self, _arg: &ProtoModuleDeclaration) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'EmbedDeclaration' fn embed_declaration(&mut self, _arg: &EmbedDeclaration) -> Result<()> { Ok(()) @@ -2436,7 +2476,7 @@ pub trait VerylGrammarTrait { // /// -/// Type derived for production 337 +/// Type derived for production 343 /// /// `Number: IntegralNumber;` /// @@ -2448,7 +2488,7 @@ pub struct NumberIntegralNumber { } /// -/// Type derived for production 338 +/// Type derived for production 344 /// /// `Number: RealNumber;` /// @@ -2460,7 +2500,7 @@ pub struct NumberRealNumber { } /// -/// Type derived for production 339 +/// Type derived for production 345 /// /// `IntegralNumber: Based;` /// @@ -2472,7 +2512,7 @@ pub struct IntegralNumberBased { } /// -/// Type derived for production 340 +/// Type derived for production 346 /// /// `IntegralNumber: BaseLess;` /// @@ -2484,7 +2524,7 @@ pub struct IntegralNumberBaseLess { } /// -/// Type derived for production 341 +/// Type derived for production 347 /// /// `IntegralNumber: AllBit;` /// @@ -2496,7 +2536,7 @@ pub struct IntegralNumberAllBit { } /// -/// Type derived for production 342 +/// Type derived for production 348 /// /// `RealNumber: FixedPoint;` /// @@ -2508,7 +2548,7 @@ pub struct RealNumberFixedPoint { } /// -/// Type derived for production 343 +/// Type derived for production 349 /// /// `RealNumber: Exponent;` /// @@ -2520,7 +2560,7 @@ pub struct RealNumberExponent { } /// -/// Type derived for production 352 +/// Type derived for production 358 /// /// `ScopedIdentifierGroup: DollarIdentifier;` /// @@ -2532,7 +2572,7 @@ pub struct ScopedIdentifierGroupDollarIdentifier { } /// -/// Type derived for production 353 +/// Type derived for production 359 /// /// `ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */;` /// @@ -2545,7 +2585,7 @@ pub struct ScopedIdentifierGroupIdentifierScopedIdentifierOpt { } /// -/// Type derived for production 396 +/// Type derived for production 402 /// /// `Expression09ListGroup: Operator10;` /// @@ -2557,7 +2597,7 @@ pub struct Expression09ListGroupOperator10 { } /// -/// Type derived for production 397 +/// Type derived for production 403 /// /// `Expression09ListGroup: Star;` /// @@ -2569,7 +2609,7 @@ pub struct Expression09ListGroupStar { } /// -/// Type derived for production 407 +/// Type derived for production 413 /// /// `Expression12ListGroup: UnaryOperator;` /// @@ -2581,7 +2621,7 @@ pub struct Expression12ListGroupUnaryOperator { } /// -/// Type derived for production 408 +/// Type derived for production 414 /// /// `Expression12ListGroup: Operator09;` /// @@ -2593,7 +2633,7 @@ pub struct Expression12ListGroupOperator09 { } /// -/// Type derived for production 409 +/// Type derived for production 415 /// /// `Expression12ListGroup: Operator05;` /// @@ -2605,7 +2645,7 @@ pub struct Expression12ListGroupOperator05 { } /// -/// Type derived for production 410 +/// Type derived for production 416 /// /// `Expression12ListGroup: Operator03;` /// @@ -2617,7 +2657,7 @@ pub struct Expression12ListGroupOperator03 { } /// -/// Type derived for production 411 +/// Type derived for production 417 /// /// `Expression12ListGroup: Operator04;` /// @@ -2629,7 +2669,7 @@ pub struct Expression12ListGroupOperator04 { } /// -/// Type derived for production 413 +/// Type derived for production 419 /// /// `Factor: Number;` /// @@ -2641,7 +2681,7 @@ pub struct FactorNumber { } /// -/// Type derived for production 414 +/// Type derived for production 420 /// /// `Factor: ExpressionIdentifier FactorOpt /* Option */;` /// @@ -2654,7 +2694,7 @@ pub struct FactorExpressionIdentifierFactorOpt { } /// -/// Type derived for production 415 +/// Type derived for production 421 /// /// `Factor: LParen Expression RParen;` /// @@ -2668,7 +2708,7 @@ pub struct FactorLParenExpressionRParen { } /// -/// Type derived for production 416 +/// Type derived for production 422 /// /// `Factor: LBrace ConcatenationList RBrace;` /// @@ -2682,7 +2722,7 @@ pub struct FactorLBraceConcatenationListRBrace { } /// -/// Type derived for production 417 +/// Type derived for production 423 /// /// `Factor: QuoteLBrace ArrayLiteralList RBrace;` /// @@ -2696,7 +2736,7 @@ pub struct FactorQuoteLBraceArrayLiteralListRBrace { } /// -/// Type derived for production 418 +/// Type derived for production 424 /// /// `Factor: IfExpression;` /// @@ -2708,7 +2748,7 @@ pub struct FactorIfExpression { } /// -/// Type derived for production 419 +/// Type derived for production 425 /// /// `Factor: CaseExpression;` /// @@ -2720,7 +2760,7 @@ pub struct FactorCaseExpression { } /// -/// Type derived for production 420 +/// Type derived for production 426 /// /// `Factor: SwitchExpression;` /// @@ -2732,7 +2772,7 @@ pub struct FactorSwitchExpression { } /// -/// Type derived for production 421 +/// Type derived for production 427 /// /// `Factor: StringLiteral;` /// @@ -2744,7 +2784,7 @@ pub struct FactorStringLiteral { } /// -/// Type derived for production 422 +/// Type derived for production 428 /// /// `Factor: FactorGroup;` /// @@ -2756,7 +2796,7 @@ pub struct FactorFactorGroup { } /// -/// Type derived for production 423 +/// Type derived for production 429 /// /// `FactorGroup: Msb;` /// @@ -2768,7 +2808,7 @@ pub struct FactorGroupMsb { } /// -/// Type derived for production 424 +/// Type derived for production 430 /// /// `FactorGroup: Lsb;` /// @@ -2780,7 +2820,7 @@ pub struct FactorGroupLsb { } /// -/// Type derived for production 425 +/// Type derived for production 431 /// /// `Factor: InsideExpression;` /// @@ -2792,7 +2832,7 @@ pub struct FactorInsideExpression { } /// -/// Type derived for production 426 +/// Type derived for production 432 /// /// `Factor: OutsideExpression;` /// @@ -2804,7 +2844,7 @@ pub struct FactorOutsideExpression { } /// -/// Type derived for production 452 +/// Type derived for production 458 /// /// `ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */;` /// @@ -2817,7 +2857,7 @@ pub struct ArrayLiteralItemGroupExpressionArrayLiteralItemOpt { } /// -/// Type derived for production 453 +/// Type derived for production 459 /// /// `ArrayLiteralItemGroup: Defaul Colon Expression;` /// @@ -2831,7 +2871,7 @@ pub struct ArrayLiteralItemGroupDefaulColonExpression { } /// -/// Type derived for production 469 +/// Type derived for production 475 /// /// `TypeExpression: ScalarType;` /// @@ -2843,7 +2883,7 @@ pub struct TypeExpressionScalarType { } /// -/// Type derived for production 470 +/// Type derived for production 476 /// /// `TypeExpression: Type LParen Expression RParen;` /// @@ -2858,7 +2898,7 @@ pub struct TypeExpressionTypeLParenExpressionRParen { } /// -/// Type derived for production 482 +/// Type derived for production 488 /// /// `SelectOperator: Colon;` /// @@ -2870,7 +2910,7 @@ pub struct SelectOperatorColon { } /// -/// Type derived for production 483 +/// Type derived for production 489 /// /// `SelectOperator: PlusColon;` /// @@ -2882,7 +2922,7 @@ pub struct SelectOperatorPlusColon { } /// -/// Type derived for production 484 +/// Type derived for production 490 /// /// `SelectOperator: MinusColon;` /// @@ -2894,7 +2934,7 @@ pub struct SelectOperatorMinusColon { } /// -/// Type derived for production 485 +/// Type derived for production 491 /// /// `SelectOperator: Step;` /// @@ -2906,7 +2946,7 @@ pub struct SelectOperatorStep { } /// -/// Type derived for production 495 +/// Type derived for production 501 /// /// `RangeOperator: DotDot;` /// @@ -2918,7 +2958,7 @@ pub struct RangeOperatorDotDot { } /// -/// Type derived for production 496 +/// Type derived for production 502 /// /// `RangeOperator: DotDotEqu;` /// @@ -2930,7 +2970,7 @@ pub struct RangeOperatorDotDotEqu { } /// -/// Type derived for production 497 +/// Type derived for production 503 /// /// `FixedType: U32;` /// @@ -2942,7 +2982,7 @@ pub struct FixedTypeU32 { } /// -/// Type derived for production 498 +/// Type derived for production 504 /// /// `FixedType: U64;` /// @@ -2954,7 +2994,7 @@ pub struct FixedTypeU64 { } /// -/// Type derived for production 499 +/// Type derived for production 505 /// /// `FixedType: I32;` /// @@ -2966,7 +3006,7 @@ pub struct FixedTypeI32 { } /// -/// Type derived for production 500 +/// Type derived for production 506 /// /// `FixedType: I64;` /// @@ -2978,7 +3018,7 @@ pub struct FixedTypeI64 { } /// -/// Type derived for production 501 +/// Type derived for production 507 /// /// `FixedType: F32;` /// @@ -2990,7 +3030,7 @@ pub struct FixedTypeF32 { } /// -/// Type derived for production 502 +/// Type derived for production 508 /// /// `FixedType: F64;` /// @@ -3002,7 +3042,7 @@ pub struct FixedTypeF64 { } /// -/// Type derived for production 503 +/// Type derived for production 509 /// /// `FixedType: Strin;` /// @@ -3014,139 +3054,139 @@ pub struct FixedTypeStrin { } /// -/// Type derived for production 505 +/// Type derived for production 510 /// -/// `VariableTypeGroup: Clock;` +/// `VariableType: Clock;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupClock { +pub struct VariableTypeClock { pub clock: Box, } /// -/// Type derived for production 506 +/// Type derived for production 511 /// -/// `VariableTypeGroup: ClockPosedge;` +/// `VariableType: ClockPosedge;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupClockPosedge { +pub struct VariableTypeClockPosedge { pub clock_posedge: Box, } /// -/// Type derived for production 507 +/// Type derived for production 512 /// -/// `VariableTypeGroup: ClockNegedge;` +/// `VariableType: ClockNegedge;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupClockNegedge { +pub struct VariableTypeClockNegedge { pub clock_negedge: Box, } /// -/// Type derived for production 508 +/// Type derived for production 513 /// -/// `VariableTypeGroup: Reset;` +/// `VariableType: Reset;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupReset { +pub struct VariableTypeReset { pub reset: Box, } /// -/// Type derived for production 509 +/// Type derived for production 514 /// -/// `VariableTypeGroup: ResetAsyncHigh;` +/// `VariableType: ResetAsyncHigh;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupResetAsyncHigh { +pub struct VariableTypeResetAsyncHigh { pub reset_async_high: Box, } /// -/// Type derived for production 510 +/// Type derived for production 515 /// -/// `VariableTypeGroup: ResetAsyncLow;` +/// `VariableType: ResetAsyncLow;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupResetAsyncLow { +pub struct VariableTypeResetAsyncLow { pub reset_async_low: Box, } /// -/// Type derived for production 511 +/// Type derived for production 516 /// -/// `VariableTypeGroup: ResetSyncHigh;` +/// `VariableType: ResetSyncHigh;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupResetSyncHigh { +pub struct VariableTypeResetSyncHigh { pub reset_sync_high: Box, } /// -/// Type derived for production 512 +/// Type derived for production 517 /// -/// `VariableTypeGroup: ResetSyncLow;` +/// `VariableType: ResetSyncLow;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupResetSyncLow { +pub struct VariableTypeResetSyncLow { pub reset_sync_low: Box, } /// -/// Type derived for production 513 +/// Type derived for production 518 /// -/// `VariableTypeGroup: Logic;` +/// `VariableType: Logic;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupLogic { +pub struct VariableTypeLogic { pub logic: Box, } /// -/// Type derived for production 514 +/// Type derived for production 519 /// -/// `VariableTypeGroup: Bit;` +/// `VariableType: Bit;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupBit { +pub struct VariableTypeBit { pub bit: Box, } /// -/// Type derived for production 515 +/// Type derived for production 520 /// -/// `VariableTypeGroup: ScopedIdentifier;` +/// `VariableType: ScopedIdentifier;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeGroupScopedIdentifier { +pub struct VariableTypeScopedIdentifier { pub scoped_identifier: Box, } /// -/// Type derived for production 518 +/// Type derived for production 521 /// /// `TypeModifier: Tri;` /// @@ -3158,7 +3198,7 @@ pub struct TypeModifierTri { } /// -/// Type derived for production 519 +/// Type derived for production 522 /// /// `TypeModifier: Signed;` /// @@ -3170,19 +3210,20 @@ pub struct TypeModifierSigned { } /// -/// Type derived for production 521 +/// Type derived for production 524 /// -/// `ScalarTypeGroup: VariableType;` +/// `ScalarTypeGroup: VariableType ScalarTypeOpt /* Option */;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct ScalarTypeGroupVariableType { +pub struct ScalarTypeGroupVariableTypeScalarTypeOpt { pub variable_type: Box, + pub scalar_type_opt: Option, } /// -/// Type derived for production 522 +/// Type derived for production 525 /// /// `ScalarTypeGroup: FixedType;` /// @@ -3194,7 +3235,7 @@ pub struct ScalarTypeGroupFixedType { } /// -/// Type derived for production 528 +/// Type derived for production 533 /// /// `CastingType: U32;` /// @@ -3206,7 +3247,7 @@ pub struct CastingTypeU32 { } /// -/// Type derived for production 529 +/// Type derived for production 534 /// /// `CastingType: U64;` /// @@ -3218,7 +3259,7 @@ pub struct CastingTypeU64 { } /// -/// Type derived for production 530 +/// Type derived for production 535 /// /// `CastingType: I32;` /// @@ -3230,7 +3271,7 @@ pub struct CastingTypeI32 { } /// -/// Type derived for production 531 +/// Type derived for production 536 /// /// `CastingType: I64;` /// @@ -3242,7 +3283,7 @@ pub struct CastingTypeI64 { } /// -/// Type derived for production 532 +/// Type derived for production 537 /// /// `CastingType: F32;` /// @@ -3254,7 +3295,7 @@ pub struct CastingTypeF32 { } /// -/// Type derived for production 533 +/// Type derived for production 538 /// /// `CastingType: F64;` /// @@ -3266,7 +3307,7 @@ pub struct CastingTypeF64 { } /// -/// Type derived for production 534 +/// Type derived for production 539 /// /// `CastingType: Clock;` /// @@ -3278,7 +3319,7 @@ pub struct CastingTypeClock { } /// -/// Type derived for production 535 +/// Type derived for production 540 /// /// `CastingType: ClockPosedge;` /// @@ -3290,7 +3331,7 @@ pub struct CastingTypeClockPosedge { } /// -/// Type derived for production 536 +/// Type derived for production 541 /// /// `CastingType: ClockNegedge;` /// @@ -3302,7 +3343,7 @@ pub struct CastingTypeClockNegedge { } /// -/// Type derived for production 537 +/// Type derived for production 542 /// /// `CastingType: Reset;` /// @@ -3314,7 +3355,7 @@ pub struct CastingTypeReset { } /// -/// Type derived for production 538 +/// Type derived for production 543 /// /// `CastingType: ResetAsyncHigh;` /// @@ -3326,7 +3367,7 @@ pub struct CastingTypeResetAsyncHigh { } /// -/// Type derived for production 539 +/// Type derived for production 544 /// /// `CastingType: ResetAsyncLow;` /// @@ -3338,7 +3379,7 @@ pub struct CastingTypeResetAsyncLow { } /// -/// Type derived for production 540 +/// Type derived for production 545 /// /// `CastingType: ResetSyncHigh;` /// @@ -3350,7 +3391,7 @@ pub struct CastingTypeResetSyncHigh { } /// -/// Type derived for production 541 +/// Type derived for production 546 /// /// `CastingType: ResetSyncLow;` /// @@ -3362,7 +3403,7 @@ pub struct CastingTypeResetSyncLow { } /// -/// Type derived for production 542 +/// Type derived for production 547 /// /// `CastingType: ScopedIdentifier;` /// @@ -3374,7 +3415,7 @@ pub struct CastingTypeScopedIdentifier { } /// -/// Type derived for production 544 +/// Type derived for production 549 /// /// `Statement: LetStatement;` /// @@ -3386,7 +3427,7 @@ pub struct StatementLetStatement { } /// -/// Type derived for production 545 +/// Type derived for production 550 /// /// `Statement: IdentifierStatement;` /// @@ -3398,7 +3439,7 @@ pub struct StatementIdentifierStatement { } /// -/// Type derived for production 546 +/// Type derived for production 551 /// /// `Statement: IfStatement;` /// @@ -3410,7 +3451,7 @@ pub struct StatementIfStatement { } /// -/// Type derived for production 547 +/// Type derived for production 552 /// /// `Statement: IfResetStatement;` /// @@ -3422,7 +3463,7 @@ pub struct StatementIfResetStatement { } /// -/// Type derived for production 548 +/// Type derived for production 553 /// /// `Statement: ReturnStatement;` /// @@ -3434,7 +3475,7 @@ pub struct StatementReturnStatement { } /// -/// Type derived for production 549 +/// Type derived for production 554 /// /// `Statement: BreakStatement;` /// @@ -3446,7 +3487,7 @@ pub struct StatementBreakStatement { } /// -/// Type derived for production 550 +/// Type derived for production 555 /// /// `Statement: ForStatement;` /// @@ -3458,7 +3499,7 @@ pub struct StatementForStatement { } /// -/// Type derived for production 551 +/// Type derived for production 556 /// /// `Statement: CaseStatement;` /// @@ -3470,7 +3511,7 @@ pub struct StatementCaseStatement { } /// -/// Type derived for production 552 +/// Type derived for production 557 /// /// `Statement: SwitchStatement;` /// @@ -3482,7 +3523,7 @@ pub struct StatementSwitchStatement { } /// -/// Type derived for production 557 +/// Type derived for production 562 /// /// `IdentifierStatementGroup: FunctionCall;` /// @@ -3494,7 +3535,7 @@ pub struct IdentifierStatementGroupFunctionCall { } /// -/// Type derived for production 558 +/// Type derived for production 563 /// /// `IdentifierStatementGroup: Assignment;` /// @@ -3506,7 +3547,7 @@ pub struct IdentifierStatementGroupAssignment { } /// -/// Type derived for production 560 +/// Type derived for production 565 /// /// `AssignmentGroup: Equ;` /// @@ -3518,7 +3559,7 @@ pub struct AssignmentGroupEqu { } /// -/// Type derived for production 561 +/// Type derived for production 566 /// /// `AssignmentGroup: AssignmentOperator;` /// @@ -3530,7 +3571,7 @@ pub struct AssignmentGroupAssignmentOperator { } /// -/// Type derived for production 595 +/// Type derived for production 600 /// /// `CaseItemGroup0: Statement;` /// @@ -3542,7 +3583,7 @@ pub struct CaseItemGroup0Statement { } /// -/// Type derived for production 596 +/// Type derived for production 601 /// /// `CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace;` /// @@ -3556,7 +3597,7 @@ pub struct CaseItemGroup0LBraceCaseItemGroup0ListRBrace { } /// -/// Type derived for production 599 +/// Type derived for production 604 /// /// `CaseItemGroup: CaseCondition;` /// @@ -3568,7 +3609,7 @@ pub struct CaseItemGroupCaseCondition { } /// -/// Type derived for production 600 +/// Type derived for production 605 /// /// `CaseItemGroup: Defaul;` /// @@ -3580,7 +3621,7 @@ pub struct CaseItemGroupDefaul { } /// -/// Type derived for production 608 +/// Type derived for production 613 /// /// `SwitchItemGroup0: Statement;` /// @@ -3592,7 +3633,7 @@ pub struct SwitchItemGroup0Statement { } /// -/// Type derived for production 609 +/// Type derived for production 614 /// /// `SwitchItemGroup0: LBrace SwitchItemGroup0List /* Vec */ RBrace;` /// @@ -3606,7 +3647,7 @@ pub struct SwitchItemGroup0LBraceSwitchItemGroup0ListRBrace { } /// -/// Type derived for production 612 +/// Type derived for production 617 /// /// `SwitchItemGroup: SwitchCondition;` /// @@ -3618,7 +3659,7 @@ pub struct SwitchItemGroupSwitchCondition { } /// -/// Type derived for production 613 +/// Type derived for production 618 /// /// `SwitchItemGroup: Defaul;` /// @@ -3630,7 +3671,7 @@ pub struct SwitchItemGroupDefaul { } /// -/// Type derived for production 625 +/// Type derived for production 630 /// /// `AttributeItem: Identifier;` /// @@ -3642,7 +3683,7 @@ pub struct AttributeItemIdentifier { } /// -/// Type derived for production 626 +/// Type derived for production 631 /// /// `AttributeItem: StringLiteral;` /// @@ -3654,7 +3695,7 @@ pub struct AttributeItemStringLiteral { } /// -/// Type derived for production 634 +/// Type derived for production 639 /// /// `LocalDeclarationGroup: ArrayType Equ Expression;` /// @@ -3668,7 +3709,7 @@ pub struct LocalDeclarationGroupArrayTypeEquExpression { } /// -/// Type derived for production 635 +/// Type derived for production 640 /// /// `LocalDeclarationGroup: Type Equ TypeExpression;` /// @@ -3682,7 +3723,7 @@ pub struct LocalDeclarationGroupTypeEquTypeExpression { } /// -/// Type derived for production 658 +/// Type derived for production 663 /// /// `ModportGroupGroup: LBrace ModportList RBrace;` /// @@ -3696,7 +3737,7 @@ pub struct ModportGroupGroupLBraceModportListRBrace { } /// -/// Type derived for production 659 +/// Type derived for production 664 /// /// `ModportGroupGroup: ModportItem;` /// @@ -3708,7 +3749,7 @@ pub struct ModportGroupGroupModportItem { } /// -/// Type derived for production 672 +/// Type derived for production 677 /// /// `EnumGroupGroup: LBrace EnumList RBrace;` /// @@ -3722,7 +3763,7 @@ pub struct EnumGroupGroupLBraceEnumListRBrace { } /// -/// Type derived for production 673 +/// Type derived for production 678 /// /// `EnumGroupGroup: EnumItem;` /// @@ -3734,7 +3775,7 @@ pub struct EnumGroupGroupEnumItem { } /// -/// Type derived for production 679 +/// Type derived for production 684 /// /// `StructUnion: Struct;` /// @@ -3746,7 +3787,7 @@ pub struct StructUnionStruct { } /// -/// Type derived for production 680 +/// Type derived for production 685 /// /// `StructUnion: Union;` /// @@ -3758,7 +3799,7 @@ pub struct StructUnionUnion { } /// -/// Type derived for production 690 +/// Type derived for production 695 /// /// `StructUnionGroupGroup: LBrace StructUnionList RBrace;` /// @@ -3772,7 +3813,7 @@ pub struct StructUnionGroupGroupLBraceStructUnionListRBrace { } /// -/// Type derived for production 691 +/// Type derived for production 696 /// /// `StructUnionGroupGroup: StructUnionItem;` /// @@ -3784,7 +3825,7 @@ pub struct StructUnionGroupGroupStructUnionItem { } /// -/// Type derived for production 719 +/// Type derived for production 724 /// /// `InstParameterGroupGroup: LBrace InstParameterList RBrace;` /// @@ -3798,7 +3839,7 @@ pub struct InstParameterGroupGroupLBraceInstParameterListRBrace { } /// -/// Type derived for production 720 +/// Type derived for production 725 /// /// `InstParameterGroupGroup: InstParameterItem;` /// @@ -3810,7 +3851,7 @@ pub struct InstParameterGroupGroupInstParameterItem { } /// -/// Type derived for production 732 +/// Type derived for production 737 /// /// `InstPortGroupGroup: LBrace InstPortList RBrace;` /// @@ -3824,7 +3865,7 @@ pub struct InstPortGroupGroupLBraceInstPortListRBrace { } /// -/// Type derived for production 733 +/// Type derived for production 738 /// /// `InstPortGroupGroup: InstPortItem;` /// @@ -3836,7 +3877,7 @@ pub struct InstPortGroupGroupInstPortItem { } /// -/// Type derived for production 748 +/// Type derived for production 753 /// /// `WithParameterGroupGroup: LBrace WithParameterList RBrace;` /// @@ -3850,7 +3891,7 @@ pub struct WithParameterGroupGroupLBraceWithParameterListRBrace { } /// -/// Type derived for production 749 +/// Type derived for production 754 /// /// `WithParameterGroupGroup: WithParameterItem;` /// @@ -3862,7 +3903,7 @@ pub struct WithParameterGroupGroupWithParameterItem { } /// -/// Type derived for production 753 +/// Type derived for production 758 /// /// `WithParameterItemGroup0: ArrayType Equ Expression;` /// @@ -3876,7 +3917,7 @@ pub struct WithParameterItemGroup0ArrayTypeEquExpression { } /// -/// Type derived for production 754 +/// Type derived for production 759 /// /// `WithParameterItemGroup0: Type Equ TypeExpression;` /// @@ -3890,7 +3931,7 @@ pub struct WithParameterItemGroup0TypeEquTypeExpression { } /// -/// Type derived for production 755 +/// Type derived for production 760 /// /// `WithParameterItemGroup: Param;` /// @@ -3902,7 +3943,7 @@ pub struct WithParameterItemGroupParam { } /// -/// Type derived for production 756 +/// Type derived for production 761 /// /// `WithParameterItemGroup: Local;` /// @@ -3914,7 +3955,43 @@ pub struct WithParameterItemGroupLocal { } /// -/// Type derived for production 774 +/// Type derived for production 762 +/// +/// `GenericBound: Const;` +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct GenericBoundConst { + pub r#const: Box, +} + +/// +/// Type derived for production 763 +/// +/// `GenericBound: Type;` +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct GenericBoundType { + pub r#type: Box, +} + +/// +/// Type derived for production 764 +/// +/// `GenericBound: ScopedIdentifier;` +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct GenericBoundScopedIdentifier { + pub scoped_identifier: Box, +} + +/// +/// Type derived for production 782 /// /// `WithGenericArgumentItem: ScopedIdentifier;` /// @@ -3926,7 +4003,7 @@ pub struct WithGenericArgumentItemScopedIdentifier { } /// -/// Type derived for production 775 +/// Type derived for production 783 /// /// `WithGenericArgumentItem: Number;` /// @@ -3938,7 +4015,7 @@ pub struct WithGenericArgumentItemNumber { } /// -/// Type derived for production 785 +/// Type derived for production 793 /// /// `PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace;` /// @@ -3952,7 +4029,7 @@ pub struct PortDeclarationGroupGroupLBracePortDeclarationListRBrace { } /// -/// Type derived for production 786 +/// Type derived for production 794 /// /// `PortDeclarationGroupGroup: PortDeclarationItem;` /// @@ -3964,7 +4041,7 @@ pub struct PortDeclarationGroupGroupPortDeclarationItem { } /// -/// Type derived for production 790 +/// Type derived for production 798 /// /// `PortDeclarationItemGroup: PortTypeConcrete;` /// @@ -3976,7 +4053,7 @@ pub struct PortDeclarationItemGroupPortTypeConcrete { } /// -/// Type derived for production 791 +/// Type derived for production 799 /// /// `PortDeclarationItemGroup: PortTypeAbstract;` /// @@ -3988,7 +4065,7 @@ pub struct PortDeclarationItemGroupPortTypeAbstract { } /// -/// Type derived for production 800 +/// Type derived for production 808 /// /// `Direction: Input;` /// @@ -4000,7 +4077,7 @@ pub struct DirectionInput { } /// -/// Type derived for production 801 +/// Type derived for production 809 /// /// `Direction: Output;` /// @@ -4012,7 +4089,7 @@ pub struct DirectionOutput { } /// -/// Type derived for production 802 +/// Type derived for production 810 /// /// `Direction: Inout;` /// @@ -4024,7 +4101,7 @@ pub struct DirectionInout { } /// -/// Type derived for production 803 +/// Type derived for production 811 /// /// `Direction: Ref;` /// @@ -4036,7 +4113,7 @@ pub struct DirectionRef { } /// -/// Type derived for production 804 +/// Type derived for production 812 /// /// `Direction: Modport;` /// @@ -4048,7 +4125,7 @@ pub struct DirectionModport { } /// -/// Type derived for production 805 +/// Type derived for production 813 /// /// `Direction: Import;` /// @@ -4060,7 +4137,7 @@ pub struct DirectionImport { } /// -/// Type derived for production 815 +/// Type derived for production 823 /// /// `FunctionItem: VarDeclaration;` /// @@ -4072,7 +4149,7 @@ pub struct FunctionItemVarDeclaration { } /// -/// Type derived for production 816 +/// Type derived for production 824 /// /// `FunctionItem: Statement;` /// @@ -4084,7 +4161,7 @@ pub struct FunctionItemStatement { } /// -/// Type derived for production 821 +/// Type derived for production 829 /// /// `ExportDeclarationGroup: Star;` /// @@ -4096,7 +4173,7 @@ pub struct ExportDeclarationGroupStar { } /// -/// Type derived for production 822 +/// Type derived for production 830 /// /// `ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */;` /// @@ -4109,7 +4186,7 @@ pub struct ExportDeclarationGroupScopedIdentifierExportDeclarationOpt { } /// -/// Type derived for production 856 +/// Type derived for production 866 /// /// `ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace;` /// @@ -4123,7 +4200,7 @@ pub struct ModuleGroupGroupLBraceModuleGroupGroupListRBrace { } /// -/// Type derived for production 859 +/// Type derived for production 869 /// /// `ModuleGroupGroup: ModuleItem;` /// @@ -4135,7 +4212,7 @@ pub struct ModuleGroupGroupModuleItem { } /// -/// Type derived for production 862 +/// Type derived for production 872 /// /// `ModuleItem: LetDeclaration;` /// @@ -4147,7 +4224,7 @@ pub struct ModuleItemLetDeclaration { } /// -/// Type derived for production 863 +/// Type derived for production 873 /// /// `ModuleItem: VarDeclaration;` /// @@ -4159,7 +4236,7 @@ pub struct ModuleItemVarDeclaration { } /// -/// Type derived for production 864 +/// Type derived for production 874 /// /// `ModuleItem: InstDeclaration;` /// @@ -4171,7 +4248,7 @@ pub struct ModuleItemInstDeclaration { } /// -/// Type derived for production 865 +/// Type derived for production 875 /// /// `ModuleItem: TypeDefDeclaration;` /// @@ -4183,7 +4260,7 @@ pub struct ModuleItemTypeDefDeclaration { } /// -/// Type derived for production 866 +/// Type derived for production 876 /// /// `ModuleItem: LocalDeclaration;` /// @@ -4195,7 +4272,7 @@ pub struct ModuleItemLocalDeclaration { } /// -/// Type derived for production 867 +/// Type derived for production 877 /// /// `ModuleItem: AlwaysFfDeclaration;` /// @@ -4207,7 +4284,7 @@ pub struct ModuleItemAlwaysFfDeclaration { } /// -/// Type derived for production 868 +/// Type derived for production 878 /// /// `ModuleItem: AlwaysCombDeclaration;` /// @@ -4219,7 +4296,7 @@ pub struct ModuleItemAlwaysCombDeclaration { } /// -/// Type derived for production 869 +/// Type derived for production 879 /// /// `ModuleItem: AssignDeclaration;` /// @@ -4231,7 +4308,7 @@ pub struct ModuleItemAssignDeclaration { } /// -/// Type derived for production 870 +/// Type derived for production 880 /// /// `ModuleItem: FunctionDeclaration;` /// @@ -4243,7 +4320,7 @@ pub struct ModuleItemFunctionDeclaration { } /// -/// Type derived for production 871 +/// Type derived for production 881 /// /// `ModuleItem: ModuleIfDeclaration;` /// @@ -4255,7 +4332,7 @@ pub struct ModuleItemModuleIfDeclaration { } /// -/// Type derived for production 872 +/// Type derived for production 882 /// /// `ModuleItem: ModuleForDeclaration;` /// @@ -4267,7 +4344,7 @@ pub struct ModuleItemModuleForDeclaration { } /// -/// Type derived for production 873 +/// Type derived for production 883 /// /// `ModuleItem: EnumDeclaration;` /// @@ -4279,7 +4356,7 @@ pub struct ModuleItemEnumDeclaration { } /// -/// Type derived for production 874 +/// Type derived for production 884 /// /// `ModuleItem: StructUnionDeclaration;` /// @@ -4291,7 +4368,7 @@ pub struct ModuleItemStructUnionDeclaration { } /// -/// Type derived for production 875 +/// Type derived for production 885 /// /// `ModuleItem: ModuleNamedBlock;` /// @@ -4303,7 +4380,7 @@ pub struct ModuleItemModuleNamedBlock { } /// -/// Type derived for production 876 +/// Type derived for production 886 /// /// `ModuleItem: ImportDeclaration;` /// @@ -4315,7 +4392,7 @@ pub struct ModuleItemImportDeclaration { } /// -/// Type derived for production 877 +/// Type derived for production 887 /// /// `ModuleItem: InitialDeclaration;` /// @@ -4327,7 +4404,7 @@ pub struct ModuleItemInitialDeclaration { } /// -/// Type derived for production 878 +/// Type derived for production 888 /// /// `ModuleItem: FinalDeclaration;` /// @@ -4339,7 +4416,7 @@ pub struct ModuleItemFinalDeclaration { } /// -/// Type derived for production 879 +/// Type derived for production 889 /// /// `ModuleItem: UnsafeBlock;` /// @@ -4351,7 +4428,7 @@ pub struct ModuleItemUnsafeBlock { } /// -/// Type derived for production 906 +/// Type derived for production 916 /// /// `InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace;` /// @@ -4365,7 +4442,7 @@ pub struct InterfaceGroupGroupLBraceInterfaceGroupGroupListRBrace { } /// -/// Type derived for production 909 +/// Type derived for production 919 /// /// `InterfaceGroupGroup: InterfaceItem;` /// @@ -4377,7 +4454,7 @@ pub struct InterfaceGroupGroupInterfaceItem { } /// -/// Type derived for production 912 +/// Type derived for production 922 /// /// `InterfaceItem: LetDeclaration;` /// @@ -4389,7 +4466,7 @@ pub struct InterfaceItemLetDeclaration { } /// -/// Type derived for production 913 +/// Type derived for production 923 /// /// `InterfaceItem: VarDeclaration;` /// @@ -4401,7 +4478,7 @@ pub struct InterfaceItemVarDeclaration { } /// -/// Type derived for production 914 +/// Type derived for production 924 /// /// `InterfaceItem: LocalDeclaration;` /// @@ -4413,7 +4490,7 @@ pub struct InterfaceItemLocalDeclaration { } /// -/// Type derived for production 915 +/// Type derived for production 925 /// /// `InterfaceItem: ModportDeclaration;` /// @@ -4425,7 +4502,7 @@ pub struct InterfaceItemModportDeclaration { } /// -/// Type derived for production 916 +/// Type derived for production 926 /// /// `InterfaceItem: InterfaceIfDeclaration;` /// @@ -4437,7 +4514,7 @@ pub struct InterfaceItemInterfaceIfDeclaration { } /// -/// Type derived for production 917 +/// Type derived for production 927 /// /// `InterfaceItem: InterfaceForDeclaration;` /// @@ -4449,7 +4526,7 @@ pub struct InterfaceItemInterfaceForDeclaration { } /// -/// Type derived for production 918 +/// Type derived for production 928 /// /// `InterfaceItem: TypeDefDeclaration;` /// @@ -4461,7 +4538,7 @@ pub struct InterfaceItemTypeDefDeclaration { } /// -/// Type derived for production 919 +/// Type derived for production 929 /// /// `InterfaceItem: EnumDeclaration;` /// @@ -4473,7 +4550,7 @@ pub struct InterfaceItemEnumDeclaration { } /// -/// Type derived for production 920 +/// Type derived for production 930 /// /// `InterfaceItem: StructUnionDeclaration;` /// @@ -4485,7 +4562,7 @@ pub struct InterfaceItemStructUnionDeclaration { } /// -/// Type derived for production 921 +/// Type derived for production 931 /// /// `InterfaceItem: InterfaceNamedBlock;` /// @@ -4497,7 +4574,7 @@ pub struct InterfaceItemInterfaceNamedBlock { } /// -/// Type derived for production 922 +/// Type derived for production 932 /// /// `InterfaceItem: FunctionDeclaration;` /// @@ -4509,7 +4586,7 @@ pub struct InterfaceItemFunctionDeclaration { } /// -/// Type derived for production 923 +/// Type derived for production 933 /// /// `InterfaceItem: ImportDeclaration;` /// @@ -4521,7 +4598,7 @@ pub struct InterfaceItemImportDeclaration { } /// -/// Type derived for production 924 +/// Type derived for production 934 /// /// `InterfaceItem: InitialDeclaration;` /// @@ -4533,7 +4610,7 @@ pub struct InterfaceItemInitialDeclaration { } /// -/// Type derived for production 925 +/// Type derived for production 935 /// /// `InterfaceItem: FinalDeclaration;` /// @@ -4545,7 +4622,7 @@ pub struct InterfaceItemFinalDeclaration { } /// -/// Type derived for production 934 +/// Type derived for production 944 /// /// `PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace;` /// @@ -4559,7 +4636,7 @@ pub struct PackageGroupGroupLBracePackageGroupGroupListRBrace { } /// -/// Type derived for production 937 +/// Type derived for production 947 /// /// `PackageGroupGroup: PackageItem;` /// @@ -4571,7 +4648,7 @@ pub struct PackageGroupGroupPackageItem { } /// -/// Type derived for production 940 +/// Type derived for production 950 /// /// `PackageItem: VarDeclaration;` /// @@ -4583,7 +4660,7 @@ pub struct PackageItemVarDeclaration { } /// -/// Type derived for production 941 +/// Type derived for production 951 /// /// `PackageItem: LocalDeclaration;` /// @@ -4595,7 +4672,7 @@ pub struct PackageItemLocalDeclaration { } /// -/// Type derived for production 942 +/// Type derived for production 952 /// /// `PackageItem: TypeDefDeclaration;` /// @@ -4607,7 +4684,7 @@ pub struct PackageItemTypeDefDeclaration { } /// -/// Type derived for production 943 +/// Type derived for production 953 /// /// `PackageItem: EnumDeclaration;` /// @@ -4619,7 +4696,7 @@ pub struct PackageItemEnumDeclaration { } /// -/// Type derived for production 944 +/// Type derived for production 954 /// /// `PackageItem: StructUnionDeclaration;` /// @@ -4631,7 +4708,7 @@ pub struct PackageItemStructUnionDeclaration { } /// -/// Type derived for production 945 +/// Type derived for production 955 /// /// `PackageItem: FunctionDeclaration;` /// @@ -4643,7 +4720,7 @@ pub struct PackageItemFunctionDeclaration { } /// -/// Type derived for production 946 +/// Type derived for production 956 /// /// `PackageItem: ImportDeclaration;` /// @@ -4655,7 +4732,7 @@ pub struct PackageItemImportDeclaration { } /// -/// Type derived for production 947 +/// Type derived for production 957 /// /// `PackageItem: ExportDeclaration;` /// @@ -4667,7 +4744,7 @@ pub struct PackageItemExportDeclaration { } /// -/// Type derived for production 948 +/// Type derived for production 958 /// /// `PackageItem: InitialDeclaration;` /// @@ -4679,7 +4756,7 @@ pub struct PackageItemInitialDeclaration { } /// -/// Type derived for production 949 +/// Type derived for production 959 /// /// `PackageItem: FinalDeclaration;` /// @@ -4691,7 +4768,7 @@ pub struct PackageItemFinalDeclaration { } /// -/// Type derived for production 955 +/// Type derived for production 972 /// /// `EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm;` /// @@ -4705,7 +4782,7 @@ pub struct EmbedItemLBraceTermEmbedItemListRBraceTerm { } /// -/// Type derived for production 958 +/// Type derived for production 975 /// /// `EmbedItem: AnyTerm;` /// @@ -4717,7 +4794,7 @@ pub struct EmbedItemAnyTerm { } /// -/// Type derived for production 961 +/// Type derived for production 978 /// /// `DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace;` /// @@ -4731,7 +4808,7 @@ pub struct DescriptionGroupGroupLBraceDescriptionGroupGroupListRBrace { } /// -/// Type derived for production 964 +/// Type derived for production 981 /// /// `DescriptionGroupGroup: DescriptionItem;` /// @@ -4743,7 +4820,7 @@ pub struct DescriptionGroupGroupDescriptionItem { } /// -/// Type derived for production 967 +/// Type derived for production 984 /// /// `DescriptionItem: ModuleDeclaration;` /// @@ -4755,7 +4832,7 @@ pub struct DescriptionItemModuleDeclaration { } /// -/// Type derived for production 968 +/// Type derived for production 985 /// /// `DescriptionItem: InterfaceDeclaration;` /// @@ -4767,7 +4844,7 @@ pub struct DescriptionItemInterfaceDeclaration { } /// -/// Type derived for production 969 +/// Type derived for production 986 /// /// `DescriptionItem: PackageDeclaration;` /// @@ -4779,7 +4856,19 @@ pub struct DescriptionItemPackageDeclaration { } /// -/// Type derived for production 970 +/// Type derived for production 987 +/// +/// `DescriptionItem: ProtoModuleDeclaration;` +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct DescriptionItemProtoModuleDeclaration { + pub proto_module_declaration: Box, +} + +/// +/// Type derived for production 988 /// /// `DescriptionItem: ImportDeclaration;` /// @@ -4791,7 +4880,7 @@ pub struct DescriptionItemImportDeclaration { } /// -/// Type derived for production 971 +/// Type derived for production 989 /// /// `DescriptionItem: EmbedDeclaration;` /// @@ -4803,7 +4892,7 @@ pub struct DescriptionItemEmbedDeclaration { } /// -/// Type derived for production 972 +/// Type derived for production 990 /// /// `DescriptionItem: IncludeDeclaration;` /// @@ -6038,6 +6127,37 @@ pub struct ConcatenationListOpt { pub comma: Box, } +/// +/// Type derived for non-terminal Const +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct Const { + pub const_token: crate::veryl_token::VerylToken, +} + +/// +/// Type derived for non-terminal ConstTerm +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ConstTerm { + pub const_term: crate::veryl_token::Token, /* (?-u:\b)const(?-u:\b) */ +} + +/// +/// Type derived for non-terminal ConstToken +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ConstToken { + pub const_term: crate::veryl_token::Token, + pub comments: Box, +} + /// /// Type derived for non-terminal Defaul /// @@ -6121,6 +6241,7 @@ pub enum DescriptionItem { ModuleDeclaration(DescriptionItemModuleDeclaration), InterfaceDeclaration(DescriptionItemInterfaceDeclaration), PackageDeclaration(DescriptionItemPackageDeclaration), + ProtoModuleDeclaration(DescriptionItemProtoModuleDeclaration), ImportDeclaration(DescriptionItemImportDeclaration), EmbedDeclaration(DescriptionItemEmbedDeclaration), IncludeDeclaration(DescriptionItemIncludeDeclaration), @@ -7416,6 +7537,17 @@ pub struct FunctionToken { pub comments: Box, } +/// +/// Type derived for non-terminal GenericBound +/// +#[allow(dead_code)] +#[derive(Debug, Clone)] +pub enum GenericBound { + Const(GenericBoundConst), + Type(GenericBoundType), + ScopedIdentifier(GenericBoundScopedIdentifier), +} + /// /// Type derived for non-terminal Hash /// @@ -9245,6 +9377,7 @@ pub struct ModuleDeclaration { pub module_declaration_opt0: Option, pub module_declaration_opt1: Option, pub module_declaration_opt2: Option, + pub module_declaration_opt3: Option, pub l_brace: Box, pub module_declaration_list: Vec, pub r_brace: Box, @@ -9287,7 +9420,8 @@ pub struct ModuleDeclarationOpt0 { #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] pub struct ModuleDeclarationOpt1 { - pub with_parameter: Box, + pub r#for: Box, + pub scoped_identifier: Box, } /// @@ -9297,6 +9431,16 @@ pub struct ModuleDeclarationOpt1 { #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] pub struct ModuleDeclarationOpt2 { + pub with_parameter: Box, +} + +/// +/// Type derived for non-terminal ModuleDeclarationOpt3 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ModuleDeclarationOpt3 { pub port_declaration: Box, } @@ -10329,6 +10473,83 @@ pub struct PortTypeConcreteOpt { pub clock_domain: Box, } +/// +/// Type derived for non-terminal Proto +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct Proto { + pub proto_token: crate::veryl_token::VerylToken, +} + +/// +/// Type derived for non-terminal ProtoModuleDeclaration +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ProtoModuleDeclaration { + pub proto_module_declaration_opt: Option, + pub proto: Box, + pub module: Box, + pub identifier: Box, + pub proto_module_declaration_opt0: Option, + pub proto_module_declaration_opt1: Option, + pub semicolon: Box, +} + +/// +/// Type derived for non-terminal ProtoModuleDeclarationOpt +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ProtoModuleDeclarationOpt { + pub r#pub: Box, +} + +/// +/// Type derived for non-terminal ProtoModuleDeclarationOpt0 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ProtoModuleDeclarationOpt0 { + pub with_parameter: Box, +} + +/// +/// Type derived for non-terminal ProtoModuleDeclarationOpt1 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ProtoModuleDeclarationOpt1 { + pub port_declaration: Box, +} + +/// +/// Type derived for non-terminal ProtoTerm +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ProtoTerm { + pub proto_term: crate::veryl_token::Token, /* (?-u:\b)proto(?-u:\b) */ +} + +/// +/// Type derived for non-terminal ProtoToken +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ProtoToken { + pub proto_term: crate::veryl_token::Token, + pub comments: Box, +} + /// /// Type derived for non-terminal Pub /// @@ -10877,7 +11098,7 @@ pub struct ScalarType { #[allow(dead_code)] #[derive(Debug, Clone)] pub enum ScalarTypeGroup { - VariableType(ScalarTypeGroupVariableType), + VariableTypeScalarTypeOpt(ScalarTypeGroupVariableTypeScalarTypeOpt), FixedType(ScalarTypeGroupFixedType), } @@ -10891,6 +11112,16 @@ pub struct ScalarTypeList { pub type_modifier: Box, } +/// +/// Type derived for non-terminal ScalarTypeOpt +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ScalarTypeOpt { + pub width: Box, +} + /// /// Type derived for non-terminal ScopedIdentifier /// @@ -11844,40 +12075,19 @@ pub struct VarToken { /// Type derived for non-terminal VariableType /// #[allow(dead_code)] -#[derive(Builder, Debug, Clone)] -#[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableType { - pub variable_type_group: Box, - pub variable_type_opt: Option, -} - -/// -/// Type derived for non-terminal VariableTypeGroup -/// -#[allow(dead_code)] #[derive(Debug, Clone)] -pub enum VariableTypeGroup { - Clock(VariableTypeGroupClock), - ClockPosedge(VariableTypeGroupClockPosedge), - ClockNegedge(VariableTypeGroupClockNegedge), - Reset(VariableTypeGroupReset), - ResetAsyncHigh(VariableTypeGroupResetAsyncHigh), - ResetAsyncLow(VariableTypeGroupResetAsyncLow), - ResetSyncHigh(VariableTypeGroupResetSyncHigh), - ResetSyncLow(VariableTypeGroupResetSyncLow), - Logic(VariableTypeGroupLogic), - Bit(VariableTypeGroupBit), - ScopedIdentifier(VariableTypeGroupScopedIdentifier), -} - -/// -/// Type derived for non-terminal VariableTypeOpt -/// -#[allow(dead_code)] -#[derive(Builder, Debug, Clone)] -#[builder(crate = "parol_runtime::derive_builder")] -pub struct VariableTypeOpt { - pub width: Box, +pub enum VariableType { + Clock(VariableTypeClock), + ClockPosedge(VariableTypeClockPosedge), + ClockNegedge(VariableTypeClockNegedge), + Reset(VariableTypeReset), + ResetAsyncHigh(VariableTypeResetAsyncHigh), + ResetAsyncLow(VariableTypeResetAsyncLow), + ResetSyncHigh(VariableTypeResetSyncHigh), + ResetSyncLow(VariableTypeResetSyncLow), + Logic(VariableTypeLogic), + Bit(VariableTypeBit), + ScopedIdentifier(VariableTypeScopedIdentifier), } /// @@ -12010,6 +12220,8 @@ pub struct WithGenericParameter { #[builder(crate = "parol_runtime::derive_builder")] pub struct WithGenericParameterItem { pub identifier: Box, + pub colon: Box, + pub generic_bound: Box, pub with_generic_parameter_item_opt: Option, } @@ -12297,6 +12509,9 @@ pub enum ASTType { ConcatenationList(ConcatenationList), ConcatenationListList(Vec), ConcatenationListOpt(Option), + Const(Const), + ConstTerm(ConstTerm), + ConstToken(ConstToken), Defaul(Defaul), DefaultTerm(DefaultTerm), DefaultToken(DefaultToken), @@ -12422,6 +12637,7 @@ pub enum ASTType { FunctionItem(FunctionItem), FunctionTerm(FunctionTerm), FunctionToken(FunctionToken), + GenericBound(GenericBound), Hash(Hash), HashTerm(HashTerm), HashToken(HashToken), @@ -12591,6 +12807,7 @@ pub enum ASTType { ModuleDeclarationOpt0(Option), ModuleDeclarationOpt1(Option), ModuleDeclarationOpt2(Option), + ModuleDeclarationOpt3(Option), ModuleForDeclaration(ModuleForDeclaration), ModuleForDeclarationOpt(Option), ModuleGroup(ModuleGroup), @@ -12685,6 +12902,13 @@ pub enum ASTType { PortTypeAbstractOpt0(Option), PortTypeConcrete(PortTypeConcrete), PortTypeConcreteOpt(Option), + Proto(Proto), + ProtoModuleDeclaration(ProtoModuleDeclaration), + ProtoModuleDeclarationOpt(Option), + ProtoModuleDeclarationOpt0(Option), + ProtoModuleDeclarationOpt1(Option), + ProtoTerm(ProtoTerm), + ProtoToken(ProtoToken), Pub(Pub), PubTerm(PubTerm), PubToken(PubToken), @@ -12739,6 +12963,7 @@ pub enum ASTType { ScalarType(ScalarType), ScalarTypeGroup(ScalarTypeGroup), ScalarTypeList(Vec), + ScalarTypeOpt(Option), ScopedIdentifier(ScopedIdentifier), ScopedIdentifierGroup(ScopedIdentifierGroup), ScopedIdentifierList(Vec), @@ -12827,8 +13052,6 @@ pub enum ASTType { VarTerm(VarTerm), VarToken(VarToken), VariableType(VariableType), - VariableTypeGroup(VariableTypeGroup), - VariableTypeOpt(Option), Veryl(Veryl), VerylList(Vec), Width(Width), @@ -13967,6 +14190,25 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 53: /// + /// `ConstTerm: /(?-u:\b)const(?-u:\b)/ : Token;` + /// + #[parol_runtime::function_name::named] + fn const_term(&mut self, const_term: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let const_term = const_term + .token()? + .try_into() + .map_err(parol_runtime::ParolError::UserError)?; + let const_term_built = ConstTerm { const_term }; + // Calling user action here + self.user_grammar.const_term(&const_term_built)?; + self.push(ASTType::ConstTerm(const_term_built), context); + Ok(()) + } + + /// Semantic action for production 54: + /// /// `DefaultTerm: /(?-u:\b)default(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] @@ -13984,7 +14226,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 54: + /// Semantic action for production 55: /// /// `ElseTerm: /(?-u:\b)else(?-u:\b)/ : Token;` /// @@ -14003,7 +14245,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 55: + /// Semantic action for production 56: /// /// `EmbedTerm: /(?-u:\b)embed(?-u:\b)/ : Token;` /// @@ -14022,7 +14264,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 56: + /// Semantic action for production 57: /// /// `EnumTerm: /(?-u:\b)enum(?-u:\b)/ : Token;` /// @@ -14041,7 +14283,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 57: + /// Semantic action for production 58: /// /// `ExportTerm: /(?-u:\b)export(?-u:\b)/ : Token;` /// @@ -14060,7 +14302,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 58: + /// Semantic action for production 59: /// /// `F32Term: /(?-u:\b)f32(?-u:\b)/ : Token;` /// @@ -14079,7 +14321,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 59: + /// Semantic action for production 60: /// /// `F64Term: /(?-u:\b)f64(?-u:\b)/ : Token;` /// @@ -14098,7 +14340,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 60: + /// Semantic action for production 61: /// /// `FinalTerm: /(?-u:\b)final(?-u:\b)/ : Token;` /// @@ -14117,7 +14359,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 61: + /// Semantic action for production 62: /// /// `ForTerm: /(?-u:\b)for(?-u:\b)/ : Token;` /// @@ -14136,7 +14378,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 62: + /// Semantic action for production 63: /// /// `FunctionTerm: /(?-u:\b)function(?-u:\b)/ : Token;` /// @@ -14155,7 +14397,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 63: + /// Semantic action for production 64: /// /// `I32Term: /(?-u:\b)i32(?-u:\b)/ : Token;` /// @@ -14174,7 +14416,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 64: + /// Semantic action for production 65: /// /// `I64Term: /(?-u:\b)i64(?-u:\b)/ : Token;` /// @@ -14193,7 +14435,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 65: + /// Semantic action for production 66: /// /// `IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/ : Token;` /// @@ -14212,7 +14454,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 66: + /// Semantic action for production 67: /// /// `IfTerm: /(?-u:\b)if(?-u:\b)/ : Token;` /// @@ -14231,7 +14473,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 67: + /// Semantic action for production 68: /// /// `ImportTerm: /(?-u:\b)import(?-u:\b)/ : Token;` /// @@ -14250,7 +14492,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 68: + /// Semantic action for production 69: /// /// `IncludeTerm: /(?-u:\b)include(?-u:\b)/ : Token;` /// @@ -14269,7 +14511,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 69: + /// Semantic action for production 70: /// /// `InitialTerm: /(?-u:\b)initial(?-u:\b)/ : Token;` /// @@ -14288,7 +14530,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 70: + /// Semantic action for production 71: /// /// `InoutTerm: /(?-u:\b)inout(?-u:\b)/ : Token;` /// @@ -14307,7 +14549,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 71: + /// Semantic action for production 72: /// /// `InputTerm: /(?-u:\b)input(?-u:\b)/ : Token;` /// @@ -14326,7 +14568,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 72: + /// Semantic action for production 73: /// /// `InsideTerm: /(?-u:\b)inside(?-u:\b)/ : Token;` /// @@ -14345,7 +14587,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 73: + /// Semantic action for production 74: /// /// `InstTerm: /(?-u:\b)inst(?-u:\b)/ : Token;` /// @@ -14364,7 +14606,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 74: + /// Semantic action for production 75: /// /// `InterfaceTerm: /(?-u:\b)interface(?-u:\b)/ : Token;` /// @@ -14383,7 +14625,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 75: + /// Semantic action for production 76: /// /// `InTerm: /(?-u:\b)in(?-u:\b)/ : Token;` /// @@ -14402,7 +14644,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 76: + /// Semantic action for production 77: /// /// `LetTerm: /(?-u:\b)let(?-u:\b)/ : Token;` /// @@ -14421,7 +14663,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 77: + /// Semantic action for production 78: /// /// `LocalTerm: /(?-u:\b)local(?-u:\b)/ : Token;` /// @@ -14440,7 +14682,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 78: + /// Semantic action for production 79: /// /// `LogicTerm: /(?-u:\b)logic(?-u:\b)/ : Token;` /// @@ -14459,7 +14701,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 79: + /// Semantic action for production 80: /// /// `LsbTerm: /(?-u:\b)lsb(?-u:\b)/ : Token;` /// @@ -14478,7 +14720,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 80: + /// Semantic action for production 81: /// /// `ModportTerm: /(?-u:\b)modport(?-u:\b)/ : Token;` /// @@ -14497,7 +14739,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 81: + /// Semantic action for production 82: /// /// `ModuleTerm: /(?-u:\b)module(?-u:\b)/ : Token;` /// @@ -14516,7 +14758,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 82: + /// Semantic action for production 83: /// /// `MsbTerm: /(?-u:\b)msb(?-u:\b)/ : Token;` /// @@ -14535,7 +14777,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 83: + /// Semantic action for production 84: /// /// `OutputTerm: /(?-u:\b)output(?-u:\b)/ : Token;` /// @@ -14554,7 +14796,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 84: + /// Semantic action for production 85: /// /// `OutsideTerm: /(?-u:\b)outside(?-u:\b)/ : Token;` /// @@ -14573,7 +14815,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 85: + /// Semantic action for production 86: /// /// `PackageTerm: /(?-u:\b)package(?-u:\b)/ : Token;` /// @@ -14592,7 +14834,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 86: + /// Semantic action for production 87: /// /// `ParamTerm: /(?-u:\b)param(?-u:\b)/ : Token;` /// @@ -14611,7 +14853,26 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 87: + /// Semantic action for production 88: + /// + /// `ProtoTerm: /(?-u:\b)proto(?-u:\b)/ : Token;` + /// + #[parol_runtime::function_name::named] + fn proto_term(&mut self, proto_term: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let proto_term = proto_term + .token()? + .try_into() + .map_err(parol_runtime::ParolError::UserError)?; + let proto_term_built = ProtoTerm { proto_term }; + // Calling user action here + self.user_grammar.proto_term(&proto_term_built)?; + self.push(ASTType::ProtoTerm(proto_term_built), context); + Ok(()) + } + + /// Semantic action for production 89: /// /// `PubTerm: /(?-u:\b)pub(?-u:\b)/ : Token;` /// @@ -14630,7 +14891,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 88: + /// Semantic action for production 90: /// /// `RefTerm: /(?-u:\b)ref(?-u:\b)/ : Token;` /// @@ -14649,7 +14910,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 89: + /// Semantic action for production 91: /// /// `RepeatTerm: /(?-u:\b)repeat(?-u:\b)/ : Token;` /// @@ -14668,7 +14929,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 90: + /// Semantic action for production 92: /// /// `ResetTerm: /(?-u:\b)reset(?-u:\b)/ : Token;` /// @@ -14687,7 +14948,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 91: + /// Semantic action for production 93: /// /// `ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/ : Token;` /// @@ -14712,7 +14973,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 92: + /// Semantic action for production 94: /// /// `ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/ : Token;` /// @@ -14737,7 +14998,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 93: + /// Semantic action for production 95: /// /// `ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/ : Token;` /// @@ -14762,7 +15023,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 94: + /// Semantic action for production 96: /// /// `ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/ : Token;` /// @@ -14787,7 +15048,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 95: + /// Semantic action for production 97: /// /// `ReturnTerm: /(?-u:\b)return(?-u:\b)/ : Token;` /// @@ -14806,7 +15067,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 96: + /// Semantic action for production 98: /// /// `BreakTerm: /(?-u:\b)break(?-u:\b)/ : Token;` /// @@ -14825,7 +15086,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 97: + /// Semantic action for production 99: /// /// `SignedTerm: /(?-u:\b)signed(?-u:\b)/ : Token;` /// @@ -14844,7 +15105,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 98: + /// Semantic action for production 100: /// /// `StepTerm: /(?-u:\b)step(?-u:\b)/ : Token;` /// @@ -14863,7 +15124,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 99: + /// Semantic action for production 101: /// /// `StringTerm: /(?-u:\b)string(?-u:\b)/ : Token;` /// @@ -14882,7 +15143,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 100: + /// Semantic action for production 102: /// /// `StructTerm: /(?-u:\b)struct(?-u:\b)/ : Token;` /// @@ -14901,7 +15162,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 101: + /// Semantic action for production 103: /// /// `SwitchTerm: /(?-u:\b)switch(?-u:\b)/ : Token;` /// @@ -14920,7 +15181,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 102: + /// Semantic action for production 104: /// /// `TriTerm: /(?-u:\b)tri(?-u:\b)/ : Token;` /// @@ -14939,7 +15200,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 103: + /// Semantic action for production 105: /// /// `TypeTerm: /(?-u:\b)type(?-u:\b)/ : Token;` /// @@ -14958,7 +15219,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 104: + /// Semantic action for production 106: /// /// `U32Term: /(?-u:\b)u32(?-u:\b)/ : Token;` /// @@ -14977,7 +15238,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 105: + /// Semantic action for production 107: /// /// `U64Term: /(?-u:\b)u64(?-u:\b)/ : Token;` /// @@ -14996,7 +15257,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 106: + /// Semantic action for production 108: /// /// `UnionTerm: /(?-u:\b)union(?-u:\b)/ : Token;` /// @@ -15015,7 +15276,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 107: + /// Semantic action for production 109: /// /// `UnsafeTerm: /(?-u:\b)unsafe(?-u:\b)/ : Token;` /// @@ -15034,7 +15295,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 108: + /// Semantic action for production 110: /// /// `VarTerm: /(?-u:\b)var(?-u:\b)/ : Token;` /// @@ -15053,7 +15314,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 109: + /// Semantic action for production 111: /// /// `DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token;` /// @@ -15078,7 +15339,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 110: + /// Semantic action for production 112: /// /// `IdentifierTerm: /(?:r#)?[a-zA-Z_][0-9a-zA-Z_$]*/ : Token;` /// @@ -15097,7 +15358,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 111: + /// Semantic action for production 113: /// /// `AnyTerm: /[^{}]*/ : Token;` /// @@ -15116,7 +15377,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 112: + /// Semantic action for production 114: /// /// `Comments: CommentsOpt /* Option */;` /// @@ -15132,7 +15393,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 113: + /// Semantic action for production 115: /// /// `CommentsOpt /* Option::Some */: CommentsTerm;` /// @@ -15148,7 +15409,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 114: + /// Semantic action for production 116: /// /// `CommentsOpt /* Option::None */: ;` /// @@ -15160,7 +15421,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 115: + /// Semantic action for production 117: /// /// `StartToken: Comments;` /// @@ -15178,7 +15439,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 116: + /// Semantic action for production 118: /// /// `StringLiteralToken: StringLiteralTerm : Token Comments;` /// @@ -15208,7 +15469,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 117: + /// Semantic action for production 119: /// /// `ExponentToken: ExponentTerm : Token Comments;` /// @@ -15234,7 +15495,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 118: + /// Semantic action for production 120: /// /// `FixedPointToken: FixedPointTerm : Token Comments;` /// @@ -15261,7 +15522,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 119: + /// Semantic action for production 121: /// /// `BasedToken: BasedTerm : Token Comments;` /// @@ -15287,7 +15548,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 120: + /// Semantic action for production 122: /// /// `BaseLessToken: BaseLessTerm : Token Comments;` /// @@ -15313,7 +15574,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 121: + /// Semantic action for production 123: /// /// `AllBitToken: AllBitTerm : Token Comments;` /// @@ -15339,7 +15600,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 122: + /// Semantic action for production 124: /// /// `AssignmentOperatorToken: AssignmentOperatorTerm : Token Comments;` /// @@ -15374,7 +15635,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 123: + /// Semantic action for production 125: /// /// `Operator01Token: Operator01Term : Token Comments;` /// @@ -15401,7 +15662,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 124: + /// Semantic action for production 126: /// /// `Operator02Token: Operator02Term : Token Comments;` /// @@ -15428,7 +15689,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 125: + /// Semantic action for production 127: /// /// `Operator03Token: Operator03Term : Token Comments;` /// @@ -15455,7 +15716,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 126: + /// Semantic action for production 128: /// /// `Operator04Token: Operator04Term : Token Comments;` /// @@ -15482,7 +15743,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 127: + /// Semantic action for production 129: /// /// `Operator05Token: Operator05Term : Token Comments;` /// @@ -15509,7 +15770,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 128: + /// Semantic action for production 130: /// /// `Operator06Token: Operator06Term : Token Comments;` /// @@ -15536,7 +15797,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 129: + /// Semantic action for production 131: /// /// `Operator07Token: Operator07Term : Token Comments;` /// @@ -15563,7 +15824,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 130: + /// Semantic action for production 132: /// /// `Operator08Token: Operator08Term : Token Comments;` /// @@ -15590,7 +15851,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 131: + /// Semantic action for production 133: /// /// `Operator09Token: Operator09Term : Token Comments;` /// @@ -15617,7 +15878,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 132: + /// Semantic action for production 134: /// /// `Operator10Token: Operator10Term : Token Comments;` /// @@ -15644,7 +15905,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 133: + /// Semantic action for production 135: /// /// `Operator11Token: Operator11Term : Token Comments;` /// @@ -15671,7 +15932,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 134: + /// Semantic action for production 136: /// /// `UnaryOperatorToken: UnaryOperatorTerm : Token Comments;` /// @@ -15701,7 +15962,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 135: + /// Semantic action for production 137: /// /// `BackQuoteToken: BackQuoteTerm : Token Comments;` /// @@ -15728,7 +15989,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 136: + /// Semantic action for production 138: /// /// `ColonToken: ColonTerm : Token Comments;` /// @@ -15754,7 +16015,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 137: + /// Semantic action for production 139: /// /// `ColonColonLAngleToken: ColonColonLAngleTerm : Token Comments;` /// @@ -15789,7 +16050,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 138: + /// Semantic action for production 140: /// /// `ColonColonToken: ColonColonTerm : Token Comments;` /// @@ -15816,7 +16077,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 139: + /// Semantic action for production 141: /// /// `CommaToken: CommaTerm : Token Comments;` /// @@ -15842,7 +16103,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 140: + /// Semantic action for production 142: /// /// `DotDotToken: DotDotTerm : Token Comments;` /// @@ -15868,7 +16129,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 141: + /// Semantic action for production 143: /// /// `DotDotEquToken: DotDotEquTerm : Token Comments;` /// @@ -15895,7 +16156,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 142: + /// Semantic action for production 144: /// /// `DotToken: DotTerm : Token Comments;` /// @@ -15921,7 +16182,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 143: + /// Semantic action for production 145: /// /// `EquToken: EquTerm : Token Comments;` /// @@ -15947,7 +16208,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 144: + /// Semantic action for production 146: /// /// `HashToken: HashTerm : Token Comments;` /// @@ -15973,7 +16234,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 145: + /// Semantic action for production 147: /// /// `QuoteLBraceToken: QuoteLBraceTerm : Token Comments;` /// @@ -16003,7 +16264,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 146: + /// Semantic action for production 148: /// /// `LAngleToken: LAngleTerm : Token Comments;` /// @@ -16029,7 +16290,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 147: + /// Semantic action for production 149: /// /// `LBraceToken: LBraceTerm : Token Comments;` /// @@ -16055,7 +16316,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 148: + /// Semantic action for production 150: /// /// `LBracketToken: LBracketTerm : Token Comments;` /// @@ -16081,7 +16342,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 149: + /// Semantic action for production 151: /// /// `LParenToken: LParenTerm : Token Comments;` /// @@ -16107,7 +16368,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 150: + /// Semantic action for production 152: /// /// `MinusColonToken: MinusColonTerm : Token Comments;` /// @@ -16134,7 +16395,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 151: + /// Semantic action for production 153: /// /// `MinusGTToken: MinusGTTerm : Token Comments;` /// @@ -16160,7 +16421,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 152: + /// Semantic action for production 154: /// /// `PlusColonToken: PlusColonTerm : Token Comments;` /// @@ -16187,7 +16448,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 153: + /// Semantic action for production 155: /// /// `RAngleToken: RAngleTerm : Token Comments;` /// @@ -16213,7 +16474,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 154: + /// Semantic action for production 156: /// /// `RBraceToken: RBraceTerm : Token Comments;` /// @@ -16239,7 +16500,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 155: + /// Semantic action for production 157: /// /// `RBracketToken: RBracketTerm : Token Comments;` /// @@ -16265,7 +16526,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 156: + /// Semantic action for production 158: /// /// `RParenToken: RParenTerm : Token Comments;` /// @@ -16291,7 +16552,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 157: + /// Semantic action for production 159: /// /// `SemicolonToken: SemicolonTerm : Token Comments;` /// @@ -16317,7 +16578,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 158: + /// Semantic action for production 160: /// /// `StarToken: StarTerm : Token Comments;` /// @@ -16343,7 +16604,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 159: + /// Semantic action for production 161: /// /// `AlwaysCombToken: AlwaysCombTerm : Token Comments;` /// @@ -16370,7 +16631,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 160: + /// Semantic action for production 162: /// /// `AlwaysFfToken: AlwaysFfTerm : Token Comments;` /// @@ -16396,7 +16657,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 161: + /// Semantic action for production 163: /// /// `AsToken: AsTerm : Token Comments;` /// @@ -16422,7 +16683,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 162: + /// Semantic action for production 164: /// /// `AssignToken: AssignTerm : Token Comments;` /// @@ -16448,7 +16709,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 163: + /// Semantic action for production 165: /// /// `BitToken: BitTerm : Token Comments;` /// @@ -16474,7 +16735,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 164: + /// Semantic action for production 166: /// /// `CaseToken: CaseTerm : Token Comments;` /// @@ -16500,7 +16761,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 165: + /// Semantic action for production 167: /// /// `ClockToken: ClockTerm : Token Comments;` /// @@ -16526,7 +16787,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 166: + /// Semantic action for production 168: /// /// `ClockPosedgeToken: ClockPosedgeTerm : Token Comments;` /// @@ -16556,7 +16817,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 167: + /// Semantic action for production 169: /// /// `ClockNegedgeToken: ClockNegedgeTerm : Token Comments;` /// @@ -16586,7 +16847,33 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 168: + /// Semantic action for production 170: + /// + /// `ConstToken: ConstTerm : Token Comments;` + /// + #[parol_runtime::function_name::named] + fn const_token( + &mut self, + _const_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 const_term = pop_item!(self, const_term, ConstTerm, context); + let const_token_built = ConstToken { + const_term: (&const_term) + .try_into() + .map_err(parol_runtime::ParolError::UserError)?, + comments: Box::new(comments), + }; + // Calling user action here + self.user_grammar.const_token(&const_token_built)?; + self.push(ASTType::ConstToken(const_token_built), context); + Ok(()) + } + + /// Semantic action for production 171: /// /// `DefaultToken: DefaultTerm : Token Comments;` /// @@ -16612,7 +16899,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 169: + /// Semantic action for production 172: /// /// `ElseToken: ElseTerm : Token Comments;` /// @@ -16638,7 +16925,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 170: + /// Semantic action for production 173: /// /// `EmbedToken: EmbedTerm : Token Comments;` /// @@ -16664,7 +16951,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 171: + /// Semantic action for production 174: /// /// `EnumToken: EnumTerm : Token Comments;` /// @@ -16690,7 +16977,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 172: + /// Semantic action for production 175: /// /// `ExportToken: ExportTerm : Token Comments;` /// @@ -16716,7 +17003,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 173: + /// Semantic action for production 176: /// /// `F32Token: F32Term : Token Comments;` /// @@ -16742,7 +17029,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 174: + /// Semantic action for production 177: /// /// `F64Token: F64Term : Token Comments;` /// @@ -16768,7 +17055,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 175: + /// Semantic action for production 178: /// /// `FinalToken: FinalTerm : Token Comments;` /// @@ -16794,7 +17081,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 176: + /// Semantic action for production 179: /// /// `ForToken: ForTerm : Token Comments;` /// @@ -16820,7 +17107,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 177: + /// Semantic action for production 180: /// /// `FunctionToken: FunctionTerm : Token Comments;` /// @@ -16846,7 +17133,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 178: + /// Semantic action for production 181: /// /// `I32Token: I32Term : Token Comments;` /// @@ -16872,7 +17159,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 179: + /// Semantic action for production 182: /// /// `I64Token: I64Term : Token Comments;` /// @@ -16898,7 +17185,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 180: + /// Semantic action for production 183: /// /// `IfResetToken: IfResetTerm : Token Comments;` /// @@ -16924,7 +17211,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 181: + /// Semantic action for production 184: /// /// `IfToken: IfTerm : Token Comments;` /// @@ -16950,7 +17237,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 182: + /// Semantic action for production 185: /// /// `ImportToken: ImportTerm : Token Comments;` /// @@ -16976,7 +17263,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 183: + /// Semantic action for production 186: /// /// `IncludeToken: IncludeTerm : Token Comments;` /// @@ -17002,7 +17289,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 184: + /// Semantic action for production 187: /// /// `InitialToken: InitialTerm : Token Comments;` /// @@ -17028,7 +17315,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 185: + /// Semantic action for production 188: /// /// `InoutToken: InoutTerm : Token Comments;` /// @@ -17054,7 +17341,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 186: + /// Semantic action for production 189: /// /// `InputToken: InputTerm : Token Comments;` /// @@ -17080,7 +17367,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 187: + /// Semantic action for production 190: /// /// `InsideToken: InsideTerm : Token Comments;` /// @@ -17106,7 +17393,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 188: + /// Semantic action for production 191: /// /// `InstToken: InstTerm : Token Comments;` /// @@ -17132,7 +17419,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 189: + /// Semantic action for production 192: /// /// `InterfaceToken: InterfaceTerm : Token Comments;` /// @@ -17158,7 +17445,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 190: + /// Semantic action for production 193: /// /// `InToken: InTerm : Token Comments;` /// @@ -17184,7 +17471,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 191: + /// Semantic action for production 194: /// /// `LetToken: LetTerm : Token Comments;` /// @@ -17210,7 +17497,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 192: + /// Semantic action for production 195: /// /// `LocalToken: LocalTerm : Token Comments;` /// @@ -17236,7 +17523,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 193: + /// Semantic action for production 196: /// /// `LogicToken: LogicTerm : Token Comments;` /// @@ -17262,7 +17549,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 194: + /// Semantic action for production 197: /// /// `LsbToken: LsbTerm : Token Comments;` /// @@ -17288,7 +17575,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 195: + /// Semantic action for production 198: /// /// `ModportToken: ModportTerm : Token Comments;` /// @@ -17314,7 +17601,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 196: + /// Semantic action for production 199: /// /// `ModuleToken: ModuleTerm : Token Comments;` /// @@ -17340,7 +17627,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 197: + /// Semantic action for production 200: /// /// `MsbToken: MsbTerm : Token Comments;` /// @@ -17366,7 +17653,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 198: + /// Semantic action for production 201: /// /// `OutputToken: OutputTerm : Token Comments;` /// @@ -17392,7 +17679,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 199: + /// Semantic action for production 202: /// /// `OutsideToken: OutsideTerm : Token Comments;` /// @@ -17418,7 +17705,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 200: + /// Semantic action for production 203: /// /// `PackageToken: PackageTerm : Token Comments;` /// @@ -17444,7 +17731,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 201: + /// Semantic action for production 204: /// /// `ParamToken: ParamTerm : Token Comments;` /// @@ -17470,7 +17757,33 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 202: + /// Semantic action for production 205: + /// + /// `ProtoToken: ProtoTerm : Token Comments;` + /// + #[parol_runtime::function_name::named] + fn proto_token( + &mut self, + _proto_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 proto_term = pop_item!(self, proto_term, ProtoTerm, context); + let proto_token_built = ProtoToken { + proto_term: (&proto_term) + .try_into() + .map_err(parol_runtime::ParolError::UserError)?, + comments: Box::new(comments), + }; + // Calling user action here + self.user_grammar.proto_token(&proto_token_built)?; + self.push(ASTType::ProtoToken(proto_token_built), context); + Ok(()) + } + + /// Semantic action for production 206: /// /// `PubToken: PubTerm : Token Comments;` /// @@ -17496,7 +17809,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 203: + /// Semantic action for production 207: /// /// `RefToken: RefTerm : Token Comments;` /// @@ -17522,7 +17835,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 204: + /// Semantic action for production 208: /// /// `RepeatToken: RepeatTerm : Token Comments;` /// @@ -17548,7 +17861,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 205: + /// Semantic action for production 209: /// /// `ResetToken: ResetTerm : Token Comments;` /// @@ -17574,7 +17887,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 206: + /// Semantic action for production 210: /// /// `ResetAsyncHighToken: ResetAsyncHighTerm : Token Comments;` /// @@ -17605,7 +17918,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 207: + /// Semantic action for production 211: /// /// `ResetAsyncLowToken: ResetAsyncLowTerm : Token Comments;` /// @@ -17636,7 +17949,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 208: + /// Semantic action for production 212: /// /// `ResetSyncHighToken: ResetSyncHighTerm : Token Comments;` /// @@ -17667,7 +17980,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 209: + /// Semantic action for production 213: /// /// `ResetSyncLowToken: ResetSyncLowTerm : Token Comments;` /// @@ -17697,7 +18010,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 210: + /// Semantic action for production 214: /// /// `ReturnToken: ReturnTerm : Token Comments;` /// @@ -17723,7 +18036,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 211: + /// Semantic action for production 215: /// /// `BreakToken: BreakTerm : Token Comments;` /// @@ -17749,7 +18062,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 212: + /// Semantic action for production 216: /// /// `SignedToken: SignedTerm : Token Comments;` /// @@ -17775,7 +18088,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 213: + /// Semantic action for production 217: /// /// `StepToken: StepTerm : Token Comments;` /// @@ -17801,7 +18114,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 214: + /// Semantic action for production 218: /// /// `StringToken: StringTerm : Token Comments;` /// @@ -17827,7 +18140,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 215: + /// Semantic action for production 219: /// /// `StructToken: StructTerm : Token Comments;` /// @@ -17853,7 +18166,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 216: + /// Semantic action for production 220: /// /// `SwitchToken: SwitchTerm : Token Comments;` /// @@ -17879,7 +18192,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 217: + /// Semantic action for production 221: /// /// `TriToken: TriTerm : Token Comments;` /// @@ -17905,7 +18218,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 218: + /// Semantic action for production 222: /// /// `TypeToken: TypeTerm : Token Comments;` /// @@ -17931,7 +18244,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 219: + /// Semantic action for production 223: /// /// `U32Token: U32Term : Token Comments;` /// @@ -17957,7 +18270,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 220: + /// Semantic action for production 224: /// /// `U64Token: U64Term : Token Comments;` /// @@ -17983,7 +18296,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 221: + /// Semantic action for production 225: /// /// `UnionToken: UnionTerm : Token Comments;` /// @@ -18009,7 +18322,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 222: + /// Semantic action for production 226: /// /// `UnsafeToken: UnsafeTerm : Token Comments;` /// @@ -18035,7 +18348,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 223: + /// Semantic action for production 227: /// /// `VarToken: VarTerm : Token Comments;` /// @@ -18061,7 +18374,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 224: + /// Semantic action for production 228: /// /// `DollarIdentifierToken: DollarIdentifierTerm : Token Comments;` /// @@ -18092,7 +18405,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 225: + /// Semantic action for production 229: /// /// `IdentifierToken: IdentifierTerm : Token Comments;` /// @@ -18119,7 +18432,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 226: + /// Semantic action for production 230: /// /// `Start: StartToken : VerylToken;` /// @@ -18139,7 +18452,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 227: + /// Semantic action for production 231: /// /// `StringLiteral: StringLiteralToken : VerylToken;` /// @@ -18160,7 +18473,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 228: + /// Semantic action for production 232: /// /// `Exponent: ExponentToken : VerylToken;` /// @@ -18180,7 +18493,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 229: + /// Semantic action for production 233: /// /// `FixedPoint: FixedPointToken : VerylToken;` /// @@ -18200,7 +18513,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 230: + /// Semantic action for production 234: /// /// `Based: BasedToken : VerylToken;` /// @@ -18220,7 +18533,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 231: + /// Semantic action for production 235: /// /// `BaseLess: BaseLessToken : VerylToken;` /// @@ -18240,7 +18553,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 232: + /// Semantic action for production 236: /// /// `AllBit: AllBitToken : VerylToken;` /// @@ -18260,7 +18573,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 233: + /// Semantic action for production 237: /// /// `AssignmentOperator: AssignmentOperatorToken : VerylToken;` /// @@ -18292,7 +18605,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 234: + /// Semantic action for production 238: /// /// `Operator01: Operator01Token : VerylToken;` /// @@ -18312,7 +18625,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 235: + /// Semantic action for production 239: /// /// `Operator02: Operator02Token : VerylToken;` /// @@ -18332,7 +18645,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 236: + /// Semantic action for production 240: /// /// `Operator03: Operator03Token : VerylToken;` /// @@ -18352,7 +18665,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 237: + /// Semantic action for production 241: /// /// `Operator04: Operator04Token : VerylToken;` /// @@ -18372,7 +18685,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 238: + /// Semantic action for production 242: /// /// `Operator05: Operator05Token : VerylToken;` /// @@ -18392,7 +18705,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 239: + /// Semantic action for production 243: /// /// `Operator06: Operator06Token : VerylToken;` /// @@ -18412,7 +18725,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 240: + /// Semantic action for production 244: /// /// `Operator07: Operator07Token : VerylToken;` /// @@ -18432,7 +18745,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 241: + /// Semantic action for production 245: /// /// `Operator08: Operator08Token : VerylToken;` /// @@ -18452,7 +18765,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 242: + /// Semantic action for production 246: /// /// `Operator09: Operator09Token : VerylToken;` /// @@ -18472,7 +18785,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 243: + /// Semantic action for production 247: /// /// `Operator10: Operator10Token : VerylToken;` /// @@ -18492,7 +18805,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 244: + /// Semantic action for production 248: /// /// `Operator11: Operator11Token : VerylToken;` /// @@ -18512,7 +18825,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 245: + /// Semantic action for production 249: /// /// `UnaryOperator: UnaryOperatorToken : VerylToken;` /// @@ -18533,7 +18846,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 246: + /// Semantic action for production 250: /// /// `BackQuote: BackQuoteToken : VerylToken;` /// @@ -18553,7 +18866,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 247: + /// Semantic action for production 251: /// /// `Colon: ColonToken : VerylToken;` /// @@ -18573,7 +18886,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 248: + /// Semantic action for production 252: /// /// `ColonColonLAngle: ColonColonLAngleToken : VerylToken;` /// @@ -18605,7 +18918,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 249: + /// Semantic action for production 253: /// /// `ColonColon: ColonColonToken : VerylToken;` /// @@ -18625,7 +18938,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 250: + /// Semantic action for production 254: /// /// `Comma: CommaToken : VerylToken;` /// @@ -18645,7 +18958,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 251: + /// Semantic action for production 255: /// /// `DotDot: DotDotToken : VerylToken;` /// @@ -18665,7 +18978,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 252: + /// Semantic action for production 256: /// /// `DotDotEqu: DotDotEquToken : VerylToken;` /// @@ -18685,7 +18998,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 253: + /// Semantic action for production 257: /// /// `Dot: DotToken : VerylToken;` /// @@ -18705,7 +19018,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 254: + /// Semantic action for production 258: /// /// `Equ: EquToken : VerylToken;` /// @@ -18725,7 +19038,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 255: + /// Semantic action for production 259: /// /// `Hash: HashToken : VerylToken;` /// @@ -18745,7 +19058,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 256: + /// Semantic action for production 260: /// /// `QuoteLBrace: QuoteLBraceToken : VerylToken;` /// @@ -18765,7 +19078,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 257: + /// Semantic action for production 261: /// /// `LAngle: LAngleToken : VerylToken;` /// @@ -18785,7 +19098,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 258: + /// Semantic action for production 262: /// /// `LBrace: LBraceToken : VerylToken;` /// @@ -18805,7 +19118,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 259: + /// Semantic action for production 263: /// /// `LBracket: LBracketToken : VerylToken;` /// @@ -18825,7 +19138,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 260: + /// Semantic action for production 264: /// /// `LParen: LParenToken : VerylToken;` /// @@ -18845,7 +19158,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 261: + /// Semantic action for production 265: /// /// `MinusColon: MinusColonToken : VerylToken;` /// @@ -18865,7 +19178,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 262: + /// Semantic action for production 266: /// /// `MinusGT: MinusGTToken : VerylToken;` /// @@ -18885,7 +19198,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 263: + /// Semantic action for production 267: /// /// `PlusColon: PlusColonToken : VerylToken;` /// @@ -18905,7 +19218,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 264: + /// Semantic action for production 268: /// /// `RAngle: RAngleToken : VerylToken;` /// @@ -18925,7 +19238,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 265: + /// Semantic action for production 269: /// /// `RBrace: RBraceToken : VerylToken;` /// @@ -18945,7 +19258,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 266: + /// Semantic action for production 270: /// /// `RBracket: RBracketToken : VerylToken;` /// @@ -18965,7 +19278,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 267: + /// Semantic action for production 271: /// /// `RParen: RParenToken : VerylToken;` /// @@ -18985,7 +19298,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 268: + /// Semantic action for production 272: /// /// `Semicolon: SemicolonToken : VerylToken;` /// @@ -19005,7 +19318,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 269: + /// Semantic action for production 273: /// /// `Star: StarToken : VerylToken;` /// @@ -19025,7 +19338,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 270: + /// Semantic action for production 274: /// /// `AlwaysComb: AlwaysCombToken : VerylToken;` /// @@ -19045,7 +19358,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 271: + /// Semantic action for production 275: /// /// `AlwaysFf: AlwaysFfToken : VerylToken;` /// @@ -19065,7 +19378,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 272: + /// Semantic action for production 276: /// /// `As: AsToken : VerylToken;` /// @@ -19085,7 +19398,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 273: + /// Semantic action for production 277: /// /// `Assign: AssignToken : VerylToken;` /// @@ -19105,7 +19418,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 274: + /// Semantic action for production 278: /// /// `Bit: BitToken : VerylToken;` /// @@ -19125,7 +19438,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 275: + /// Semantic action for production 279: /// /// `Break: BreakToken : VerylToken;` /// @@ -19145,7 +19458,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 276: + /// Semantic action for production 280: /// /// `Case: CaseToken : VerylToken;` /// @@ -19165,7 +19478,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 277: + /// Semantic action for production 281: /// /// `Clock: ClockToken : VerylToken;` /// @@ -19185,7 +19498,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 278: + /// Semantic action for production 282: /// /// `ClockPosedge: ClockPosedgeToken : VerylToken;` /// @@ -19205,7 +19518,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 279: + /// Semantic action for production 283: /// /// `ClockNegedge: ClockNegedgeToken : VerylToken;` /// @@ -19225,7 +19538,27 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 280: + /// Semantic action for production 284: + /// + /// `Const: ConstToken : VerylToken;` + /// + #[parol_runtime::function_name::named] + fn r#const(&mut self, _const_token: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let const_token = pop_item!(self, const_token, ConstToken, context); + let r#const_built = Const { + const_token: (&const_token) + .try_into() + .map_err(parol_runtime::ParolError::UserError)?, + }; + // Calling user action here + self.user_grammar.r#const(&r#const_built)?; + self.push(ASTType::Const(r#const_built), context); + Ok(()) + } + + /// Semantic action for production 285: /// /// `Defaul: DefaultToken : VerylToken;` /// @@ -19245,7 +19578,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 281: + /// Semantic action for production 286: /// /// `Else: ElseToken : VerylToken;` /// @@ -19265,7 +19598,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 282: + /// Semantic action for production 287: /// /// `Embed: EmbedToken : VerylToken;` /// @@ -19285,7 +19618,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 283: + /// Semantic action for production 288: /// /// `Enum: EnumToken : VerylToken;` /// @@ -19305,7 +19638,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 284: + /// Semantic action for production 289: /// /// `Export: ExportToken : VerylToken;` /// @@ -19325,7 +19658,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 285: + /// Semantic action for production 290: /// /// `F32: F32Token : VerylToken;` /// @@ -19345,7 +19678,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 286: + /// Semantic action for production 291: /// /// `F64: F64Token : VerylToken;` /// @@ -19365,7 +19698,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 287: + /// Semantic action for production 292: /// /// `Final: FinalToken : VerylToken;` /// @@ -19385,7 +19718,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 288: + /// Semantic action for production 293: /// /// `For: ForToken : VerylToken;` /// @@ -19405,7 +19738,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 289: + /// Semantic action for production 294: /// /// `Function: FunctionToken : VerylToken;` /// @@ -19425,7 +19758,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 290: + /// Semantic action for production 295: /// /// `I32: I32Token : VerylToken;` /// @@ -19445,7 +19778,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 291: + /// Semantic action for production 296: /// /// `I64: I64Token : VerylToken;` /// @@ -19465,7 +19798,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 292: + /// Semantic action for production 297: /// /// `If: IfToken : VerylToken;` /// @@ -19485,7 +19818,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 293: + /// Semantic action for production 298: /// /// `IfReset: IfResetToken : VerylToken;` /// @@ -19505,7 +19838,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 294: + /// Semantic action for production 299: /// /// `Import: ImportToken : VerylToken;` /// @@ -19525,7 +19858,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 295: + /// Semantic action for production 300: /// /// `In: InToken : VerylToken;` /// @@ -19545,7 +19878,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 296: + /// Semantic action for production 301: /// /// `Include: IncludeToken : VerylToken;` /// @@ -19565,7 +19898,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 297: + /// Semantic action for production 302: /// /// `Initial: InitialToken : VerylToken;` /// @@ -19585,7 +19918,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 298: + /// Semantic action for production 303: /// /// `Inout: InoutToken : VerylToken;` /// @@ -19605,7 +19938,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 299: + /// Semantic action for production 304: /// /// `Input: InputToken : VerylToken;` /// @@ -19625,7 +19958,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 300: + /// Semantic action for production 305: /// /// `Inside: InsideToken : VerylToken;` /// @@ -19645,7 +19978,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 301: + /// Semantic action for production 306: /// /// `Inst: InstToken : VerylToken;` /// @@ -19665,7 +19998,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 302: + /// Semantic action for production 307: /// /// `Interface: InterfaceToken : VerylToken;` /// @@ -19685,7 +20018,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 303: + /// Semantic action for production 308: /// /// `Let: LetToken : VerylToken;` /// @@ -19705,7 +20038,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 304: + /// Semantic action for production 309: /// /// `Local: LocalToken : VerylToken;` /// @@ -19725,7 +20058,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 305: + /// Semantic action for production 310: /// /// `Logic: LogicToken : VerylToken;` /// @@ -19745,7 +20078,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 306: + /// Semantic action for production 311: /// /// `Lsb: LsbToken : VerylToken;` /// @@ -19765,7 +20098,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 307: + /// Semantic action for production 312: /// /// `Modport: ModportToken : VerylToken;` /// @@ -19785,7 +20118,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 308: + /// Semantic action for production 313: /// /// `Module: ModuleToken : VerylToken;` /// @@ -19805,7 +20138,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 309: + /// Semantic action for production 314: /// /// `Msb: MsbToken : VerylToken;` /// @@ -19825,7 +20158,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 310: + /// Semantic action for production 315: /// /// `Output: OutputToken : VerylToken;` /// @@ -19845,7 +20178,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 311: + /// Semantic action for production 316: /// /// `Outside: OutsideToken : VerylToken;` /// @@ -19865,7 +20198,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 312: + /// Semantic action for production 317: /// /// `Package: PackageToken : VerylToken;` /// @@ -19885,7 +20218,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 313: + /// Semantic action for production 318: /// /// `Param: ParamToken : VerylToken;` /// @@ -19905,7 +20238,27 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 314: + /// Semantic action for production 319: + /// + /// `Proto: ProtoToken : VerylToken;` + /// + #[parol_runtime::function_name::named] + fn proto(&mut self, _proto_token: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let proto_token = pop_item!(self, proto_token, ProtoToken, context); + let proto_built = Proto { + proto_token: (&proto_token) + .try_into() + .map_err(parol_runtime::ParolError::UserError)?, + }; + // Calling user action here + self.user_grammar.proto(&proto_built)?; + self.push(ASTType::Proto(proto_built), context); + Ok(()) + } + + /// Semantic action for production 320: /// /// `Pub: PubToken : VerylToken;` /// @@ -19925,7 +20278,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 315: + /// Semantic action for production 321: /// /// `Ref: RefToken : VerylToken;` /// @@ -19945,7 +20298,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 316: + /// Semantic action for production 322: /// /// `Repeat: RepeatToken : VerylToken;` /// @@ -19965,7 +20318,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 317: + /// Semantic action for production 323: /// /// `Reset: ResetToken : VerylToken;` /// @@ -19985,7 +20338,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 318: + /// Semantic action for production 324: /// /// `ResetAsyncHigh: ResetAsyncHighToken : VerylToken;` /// @@ -20007,7 +20360,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 319: + /// Semantic action for production 325: /// /// `ResetAsyncLow: ResetAsyncLowToken : VerylToken;` /// @@ -20028,7 +20381,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 320: + /// Semantic action for production 326: /// /// `ResetSyncHigh: ResetSyncHighToken : VerylToken;` /// @@ -20049,7 +20402,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 321: + /// Semantic action for production 327: /// /// `ResetSyncLow: ResetSyncLowToken : VerylToken;` /// @@ -20070,7 +20423,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 322: + /// Semantic action for production 328: /// /// `Return: ReturnToken : VerylToken;` /// @@ -20090,7 +20443,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 323: + /// Semantic action for production 329: /// /// `Signed: SignedToken : VerylToken;` /// @@ -20110,7 +20463,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 324: + /// Semantic action for production 330: /// /// `Step: StepToken : VerylToken;` /// @@ -20130,7 +20483,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 325: + /// Semantic action for production 331: /// /// `Strin: StringToken : VerylToken;` /// @@ -20150,7 +20503,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 326: + /// Semantic action for production 332: /// /// `Struct: StructToken : VerylToken;` /// @@ -20170,7 +20523,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 327: + /// Semantic action for production 333: /// /// `Switch: SwitchToken : VerylToken;` /// @@ -20190,7 +20543,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 328: + /// Semantic action for production 334: /// /// `Tri: TriToken : VerylToken;` /// @@ -20210,7 +20563,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 329: + /// Semantic action for production 335: /// /// `Type: TypeToken : VerylToken;` /// @@ -20230,7 +20583,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 330: + /// Semantic action for production 336: /// /// `U32: U32Token : VerylToken;` /// @@ -20250,7 +20603,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 331: + /// Semantic action for production 337: /// /// `U64: U64Token : VerylToken;` /// @@ -20270,7 +20623,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 332: + /// Semantic action for production 338: /// /// `Union: UnionToken : VerylToken;` /// @@ -20290,7 +20643,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 333: + /// Semantic action for production 339: /// /// `Unsafe: UnsafeToken : VerylToken;` /// @@ -20310,7 +20663,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 334: + /// Semantic action for production 340: /// /// `Var: VarToken : VerylToken;` /// @@ -20330,7 +20683,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 335: + /// Semantic action for production 341: /// /// `DollarIdentifier: DollarIdentifierToken : VerylToken;` /// @@ -20356,7 +20709,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 336: + /// Semantic action for production 342: /// /// `Identifier: IdentifierToken : VerylToken;` /// @@ -20376,7 +20729,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 337: + /// Semantic action for production 343: /// /// `Number: IntegralNumber;` /// @@ -20395,7 +20748,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 338: + /// Semantic action for production 344: /// /// `Number: RealNumber;` /// @@ -20414,7 +20767,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 339: + /// Semantic action for production 345: /// /// `IntegralNumber: Based;` /// @@ -20434,7 +20787,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 340: + /// Semantic action for production 346: /// /// `IntegralNumber: BaseLess;` /// @@ -20454,7 +20807,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 341: + /// Semantic action for production 347: /// /// `IntegralNumber: AllBit;` /// @@ -20474,7 +20827,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 342: + /// Semantic action for production 348: /// /// `RealNumber: FixedPoint;` /// @@ -20493,7 +20846,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 343: + /// Semantic action for production 349: /// /// `RealNumber: Exponent;` /// @@ -20512,7 +20865,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 344: + /// Semantic action for production 350: /// /// `HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */;` /// @@ -20553,7 +20906,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 345: + /// Semantic action for production 351: /// /// `HierarchicalIdentifierList0 /* Vec::Push */: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0;` /// @@ -20595,7 +20948,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 346: + /// Semantic action for production 352: /// /// `HierarchicalIdentifierList0List /* Vec::Push */: Select HierarchicalIdentifierList0List;` /// @@ -20626,7 +20979,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 347: + /// Semantic action for production 353: /// /// `HierarchicalIdentifierList0List /* Vec::New */: ;` /// @@ -20642,7 +20995,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 348: + /// Semantic action for production 354: /// /// `HierarchicalIdentifierList0 /* Vec::New */: ;` /// @@ -20658,7 +21011,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 349: + /// Semantic action for production 355: /// /// `HierarchicalIdentifierList /* Vec::Push */: Select HierarchicalIdentifierList;` /// @@ -20689,7 +21042,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 350: + /// Semantic action for production 356: /// /// `HierarchicalIdentifierList /* Vec::New */: ;` /// @@ -20705,7 +21058,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 351: + /// Semantic action for production 357: /// /// `ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */;` /// @@ -20736,7 +21089,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 352: + /// Semantic action for production 358: /// /// `ScopedIdentifierGroup: DollarIdentifier;` /// @@ -20757,7 +21110,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 353: + /// Semantic action for production 359: /// /// `ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */;` /// @@ -20785,7 +21138,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 354: + /// Semantic action for production 360: /// /// `ScopedIdentifierList /* Vec::Push */: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList;` /// @@ -20819,7 +21172,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 355: + /// Semantic action for production 361: /// /// `ScopedIdentifierList /* Vec::New */: ;` /// @@ -20835,7 +21188,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 356: + /// Semantic action for production 362: /// /// `ScopedIdentifierOpt0 /* Option::Some */: WithGenericArgument;` /// @@ -20858,7 +21211,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 357: + /// Semantic action for production 363: /// /// `ScopedIdentifierOpt0 /* Option::None */: ;` /// @@ -20870,7 +21223,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 358: + /// Semantic action for production 364: /// /// `ScopedIdentifierOpt /* Option::Some */: WithGenericArgument;` /// @@ -20893,7 +21246,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 359: + /// Semantic action for production 365: /// /// `ScopedIdentifierOpt /* Option::None */: ;` /// @@ -20905,7 +21258,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 360: + /// Semantic action for production 366: /// /// `ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */;` /// @@ -20946,7 +21299,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 361: + /// Semantic action for production 367: /// /// `ExpressionIdentifierList0 /* Vec::Push */: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0;` /// @@ -20988,7 +21341,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 362: + /// Semantic action for production 368: /// /// `ExpressionIdentifierList0List /* Vec::Push */: Select ExpressionIdentifierList0List;` /// @@ -21019,7 +21372,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 363: + /// Semantic action for production 369: /// /// `ExpressionIdentifierList0List /* Vec::New */: ;` /// @@ -21035,7 +21388,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 364: + /// Semantic action for production 370: /// /// `ExpressionIdentifierList0 /* Vec::New */: ;` /// @@ -21051,7 +21404,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 365: + /// Semantic action for production 371: /// /// `ExpressionIdentifierList /* Vec::Push */: Select ExpressionIdentifierList;` /// @@ -21082,7 +21435,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 366: + /// Semantic action for production 372: /// /// `ExpressionIdentifierList /* Vec::New */: ;` /// @@ -21098,7 +21451,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 367: + /// Semantic action for production 373: /// /// `Expression: Expression01 ExpressionList /* Vec */;` /// @@ -21122,7 +21475,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 368: + /// Semantic action for production 374: /// /// `ExpressionList /* Vec::Push */: Operator01 Expression01 ExpressionList;` /// @@ -21148,7 +21501,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 369: + /// Semantic action for production 375: /// /// `ExpressionList /* Vec::New */: ;` /// @@ -21161,7 +21514,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 370: + /// Semantic action for production 376: /// /// `Expression01: Expression02 Expression01List /* Vec */;` /// @@ -21186,7 +21539,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 371: + /// Semantic action for production 377: /// /// `Expression01List /* Vec::Push */: Operator02 Expression02 Expression01List;` /// @@ -21212,7 +21565,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 372: + /// Semantic action for production 378: /// /// `Expression01List /* Vec::New */: ;` /// @@ -21228,7 +21581,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 373: + /// Semantic action for production 379: /// /// `Expression02: Expression03 Expression02List /* Vec */;` /// @@ -21253,7 +21606,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 374: + /// Semantic action for production 380: /// /// `Expression02List /* Vec::Push */: Operator03 Expression03 Expression02List;` /// @@ -21279,7 +21632,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 375: + /// Semantic action for production 381: /// /// `Expression02List /* Vec::New */: ;` /// @@ -21295,7 +21648,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 376: + /// Semantic action for production 382: /// /// `Expression03: Expression04 Expression03List /* Vec */;` /// @@ -21320,7 +21673,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 377: + /// Semantic action for production 383: /// /// `Expression03List /* Vec::Push */: Operator04 Expression04 Expression03List;` /// @@ -21346,7 +21699,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 378: + /// Semantic action for production 384: /// /// `Expression03List /* Vec::New */: ;` /// @@ -21362,7 +21715,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 379: + /// Semantic action for production 385: /// /// `Expression04: Expression05 Expression04List /* Vec */;` /// @@ -21387,7 +21740,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 380: + /// Semantic action for production 386: /// /// `Expression04List /* Vec::Push */: Operator05 Expression05 Expression04List;` /// @@ -21413,7 +21766,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 381: + /// Semantic action for production 387: /// /// `Expression04List /* Vec::New */: ;` /// @@ -21429,7 +21782,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 382: + /// Semantic action for production 388: /// /// `Expression05: Expression06 Expression05List /* Vec */;` /// @@ -21454,7 +21807,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 383: + /// Semantic action for production 389: /// /// `Expression05List /* Vec::Push */: Operator06 Expression06 Expression05List;` /// @@ -21480,7 +21833,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 384: + /// Semantic action for production 390: /// /// `Expression05List /* Vec::New */: ;` /// @@ -21496,7 +21849,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 385: + /// Semantic action for production 391: /// /// `Expression06: Expression07 Expression06List /* Vec */;` /// @@ -21521,7 +21874,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 386: + /// Semantic action for production 392: /// /// `Expression06List /* Vec::Push */: Operator07 Expression07 Expression06List;` /// @@ -21547,7 +21900,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 387: + /// Semantic action for production 393: /// /// `Expression06List /* Vec::New */: ;` /// @@ -21563,7 +21916,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 388: + /// Semantic action for production 394: /// /// `Expression07: Expression08 Expression07List /* Vec */;` /// @@ -21588,7 +21941,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 389: + /// Semantic action for production 395: /// /// `Expression07List /* Vec::Push */: Operator08 Expression08 Expression07List;` /// @@ -21614,7 +21967,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 390: + /// Semantic action for production 396: /// /// `Expression07List /* Vec::New */: ;` /// @@ -21630,7 +21983,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 391: + /// Semantic action for production 397: /// /// `Expression08: Expression09 Expression08List /* Vec */;` /// @@ -21655,7 +22008,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 392: + /// Semantic action for production 398: /// /// `Expression08List /* Vec::Push */: Operator09 Expression09 Expression08List;` /// @@ -21681,7 +22034,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 393: + /// Semantic action for production 399: /// /// `Expression08List /* Vec::New */: ;` /// @@ -21697,7 +22050,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 394: + /// Semantic action for production 400: /// /// `Expression09: Expression10 Expression09List /* Vec */;` /// @@ -21722,7 +22075,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 395: + /// Semantic action for production 401: /// /// `Expression09List /* Vec::Push */: Expression09ListGroup Expression10 Expression09List;` /// @@ -21753,7 +22106,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 396: + /// Semantic action for production 402: /// /// `Expression09ListGroup: Operator10;` /// @@ -21774,7 +22127,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 397: + /// Semantic action for production 403: /// /// `Expression09ListGroup: Star;` /// @@ -21795,7 +22148,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 398: + /// Semantic action for production 404: /// /// `Expression09List /* Vec::New */: ;` /// @@ -21811,7 +22164,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 399: + /// Semantic action for production 405: /// /// `Expression10: Expression11 Expression10List /* Vec */;` /// @@ -21836,7 +22189,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 400: + /// Semantic action for production 406: /// /// `Expression10List /* Vec::Push */: Operator11 Expression11 Expression10List;` /// @@ -21862,7 +22215,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 401: + /// Semantic action for production 407: /// /// `Expression10List /* Vec::New */: ;` /// @@ -21878,7 +22231,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 402: + /// Semantic action for production 408: /// /// `Expression11: Expression12 Expression11Opt /* Option */;` /// @@ -21902,7 +22255,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 403: + /// Semantic action for production 409: /// /// `Expression11Opt /* Option::Some */: As CastingType;` /// @@ -21927,7 +22280,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 404: + /// Semantic action for production 410: /// /// `Expression11Opt /* Option::None */: ;` /// @@ -21939,7 +22292,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 405: + /// Semantic action for production 411: /// /// `Expression12: Expression12List /* Vec */ Factor;` /// @@ -21964,7 +22317,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 406: + /// Semantic action for production 412: /// /// `Expression12List /* Vec::Push */: Expression12ListGroup Expression12List;` /// @@ -21992,7 +22345,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 407: + /// Semantic action for production 413: /// /// `Expression12ListGroup: UnaryOperator;` /// @@ -22013,7 +22366,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 408: + /// Semantic action for production 414: /// /// `Expression12ListGroup: Operator09;` /// @@ -22034,7 +22387,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 409: + /// Semantic action for production 415: /// /// `Expression12ListGroup: Operator05;` /// @@ -22055,7 +22408,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 410: + /// Semantic action for production 416: /// /// `Expression12ListGroup: Operator03;` /// @@ -22076,7 +22429,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 411: + /// Semantic action for production 417: /// /// `Expression12ListGroup: Operator04;` /// @@ -22097,7 +22450,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 412: + /// Semantic action for production 418: /// /// `Expression12List /* Vec::New */: ;` /// @@ -22113,7 +22466,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 413: + /// Semantic action for production 419: /// /// `Factor: Number;` /// @@ -22132,7 +22485,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 414: + /// Semantic action for production 420: /// /// `Factor: ExpressionIdentifier FactorOpt /* Option */;` /// @@ -22158,7 +22511,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 415: + /// Semantic action for production 421: /// /// `Factor: LParen Expression RParen;` /// @@ -22186,7 +22539,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 416: + /// Semantic action for production 422: /// /// `Factor: LBrace ConcatenationList RBrace;` /// @@ -22214,7 +22567,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 417: + /// Semantic action for production 423: /// /// `Factor: QuoteLBrace ArrayLiteralList RBrace;` /// @@ -22242,7 +22595,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 418: + /// Semantic action for production 424: /// /// `Factor: IfExpression;` /// @@ -22261,7 +22614,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 419: + /// Semantic action for production 425: /// /// `Factor: CaseExpression;` /// @@ -22280,7 +22633,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 420: + /// Semantic action for production 426: /// /// `Factor: SwitchExpression;` /// @@ -22299,7 +22652,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 421: + /// Semantic action for production 427: /// /// `Factor: StringLiteral;` /// @@ -22318,7 +22671,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 422: + /// Semantic action for production 428: /// /// `Factor: FactorGroup;` /// @@ -22337,7 +22690,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 423: + /// Semantic action for production 429: /// /// `FactorGroup: Msb;` /// @@ -22352,7 +22705,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 424: + /// Semantic action for production 430: /// /// `FactorGroup: Lsb;` /// @@ -22367,7 +22720,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 425: + /// Semantic action for production 431: /// /// `Factor: InsideExpression;` /// @@ -22386,7 +22739,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 426: + /// Semantic action for production 432: /// /// `Factor: OutsideExpression;` /// @@ -22405,7 +22758,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 427: + /// Semantic action for production 433: /// /// `FactorOpt /* Option::Some */: FunctionCall;` /// @@ -22421,7 +22774,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 428: + /// Semantic action for production 434: /// /// `FactorOpt /* Option::None */: ;` /// @@ -22433,7 +22786,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 429: + /// Semantic action for production 435: /// /// `FunctionCall: LParen FunctionCallOpt /* Option */ RParen;` /// @@ -22460,7 +22813,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 430: + /// Semantic action for production 436: /// /// `FunctionCallOpt /* Option::Some */: ArgumentList;` /// @@ -22479,7 +22832,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 431: + /// Semantic action for production 437: /// /// `FunctionCallOpt /* Option::None */: ;` /// @@ -22491,7 +22844,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 432: + /// Semantic action for production 438: /// /// `ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */;` /// @@ -22519,7 +22872,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 433: + /// Semantic action for production 439: /// /// `ArgumentListList /* Vec::Push */: Comma ArgumentItem ArgumentListList;` /// @@ -22545,7 +22898,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 434: + /// Semantic action for production 440: /// /// `ArgumentListList /* Vec::New */: ;` /// @@ -22561,7 +22914,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 435: + /// Semantic action for production 441: /// /// `ArgumentListOpt /* Option::Some */: Comma;` /// @@ -22580,7 +22933,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 436: + /// Semantic action for production 442: /// /// `ArgumentListOpt /* Option::None */: ;` /// @@ -22592,7 +22945,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 437: + /// Semantic action for production 443: /// /// `ArgumentItem: Expression;` /// @@ -22610,7 +22963,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 438: + /// Semantic action for production 444: /// /// `ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */;` /// @@ -22647,7 +23000,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 439: + /// Semantic action for production 445: /// /// `ConcatenationListList /* Vec::Push */: Comma ConcatenationItem ConcatenationListList;` /// @@ -22681,7 +23034,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 440: + /// Semantic action for production 446: /// /// `ConcatenationListList /* Vec::New */: ;` /// @@ -22697,7 +23050,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 441: + /// Semantic action for production 447: /// /// `ConcatenationListOpt /* Option::Some */: Comma;` /// @@ -22716,7 +23069,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 442: + /// Semantic action for production 448: /// /// `ConcatenationListOpt /* Option::None */: ;` /// @@ -22728,7 +23081,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 443: + /// Semantic action for production 449: /// /// `ConcatenationItem: Expression ConcatenationItemOpt /* Option */;` /// @@ -22757,7 +23110,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 444: + /// Semantic action for production 450: /// /// `ConcatenationItemOpt /* Option::Some */: Repeat Expression;` /// @@ -22782,7 +23135,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 445: + /// Semantic action for production 451: /// /// `ConcatenationItemOpt /* Option::None */: ;` /// @@ -22794,7 +23147,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 446: + /// Semantic action for production 452: /// /// `ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */;` /// @@ -22824,7 +23177,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 447: + /// Semantic action for production 453: /// /// `ArrayLiteralListList /* Vec::Push */: Comma ArrayLiteralItem ArrayLiteralListList;` /// @@ -22854,7 +23207,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 448: + /// Semantic action for production 454: /// /// `ArrayLiteralListList /* Vec::New */: ;` /// @@ -22870,7 +23223,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 449: + /// Semantic action for production 455: /// /// `ArrayLiteralListOpt /* Option::Some */: Comma;` /// @@ -22889,7 +23242,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 450: + /// Semantic action for production 456: /// /// `ArrayLiteralListOpt /* Option::None */: ;` /// @@ -22901,7 +23254,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 451: + /// Semantic action for production 457: /// /// `ArrayLiteralItem: ArrayLiteralItemGroup;` /// @@ -22925,7 +23278,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 452: + /// Semantic action for production 458: /// /// `ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */;` /// @@ -22953,7 +23306,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 453: + /// Semantic action for production 459: /// /// `ArrayLiteralItemGroup: Defaul Colon Expression;` /// @@ -22983,7 +23336,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 454: + /// Semantic action for production 460: /// /// `ArrayLiteralItemOpt /* Option::Some */: Repeat Expression;` /// @@ -23008,7 +23361,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 455: + /// Semantic action for production 461: /// /// `ArrayLiteralItemOpt /* Option::None */: ;` /// @@ -23020,7 +23373,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 456: + /// Semantic action for production 462: /// /// `IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace;` /// @@ -23069,7 +23422,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 457: + /// Semantic action for production 463: /// /// `IfExpressionList /* Vec::Push */: Else If Expression LBrace Expression RBrace IfExpressionList;` /// @@ -23107,7 +23460,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 458: + /// Semantic action for production 464: /// /// `IfExpressionList /* Vec::New */: ;` /// @@ -23123,7 +23476,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 459: + /// Semantic action for production 465: /// /// `CaseExpression: Case Expression LBrace CaseCondition Colon Expression Comma CaseExpressionList /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace;` /// @@ -23181,7 +23534,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 460: + /// Semantic action for production 466: /// /// `CaseExpressionList /* Vec::Push */: CaseCondition Colon Expression Comma CaseExpressionList;` /// @@ -23214,7 +23567,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 461: + /// Semantic action for production 467: /// /// `CaseExpressionList /* Vec::New */: ;` /// @@ -23230,7 +23583,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 462: + /// Semantic action for production 468: /// /// `CaseExpressionOpt /* Option::Some */: Comma;` /// @@ -23249,7 +23602,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 463: + /// Semantic action for production 469: /// /// `CaseExpressionOpt /* Option::None */: ;` /// @@ -23261,7 +23614,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 464: + /// Semantic action for production 470: /// /// `SwitchExpression: Switch LBrace SwitchCondition Colon Expression Comma SwitchExpressionList /* Vec */ Defaul Colon Expression SwitchExpressionOpt /* Option */ RBrace;` /// @@ -23318,7 +23671,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 465: + /// Semantic action for production 471: /// /// `SwitchExpressionList /* Vec::Push */: SwitchCondition Colon Expression Comma SwitchExpressionList;` /// @@ -23354,7 +23707,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 466: + /// Semantic action for production 472: /// /// `SwitchExpressionList /* Vec::New */: ;` /// @@ -23370,7 +23723,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 467: + /// Semantic action for production 473: /// /// `SwitchExpressionOpt /* Option::Some */: Comma;` /// @@ -23389,7 +23742,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 468: + /// Semantic action for production 474: /// /// `SwitchExpressionOpt /* Option::None */: ;` /// @@ -23401,7 +23754,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 469: + /// Semantic action for production 475: /// /// `TypeExpression: ScalarType;` /// @@ -23421,7 +23774,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 470: + /// Semantic action for production 476: /// /// `TypeExpression: Type LParen Expression RParen;` /// @@ -23454,7 +23807,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 471: + /// Semantic action for production 477: /// /// `InsideExpression: Inside Expression LBrace RangeList RBrace;` /// @@ -23488,7 +23841,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 472: + /// Semantic action for production 478: /// /// `OutsideExpression: Outside Expression LBrace RangeList RBrace;` /// @@ -23525,7 +23878,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 473: + /// Semantic action for production 479: /// /// `RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */;` /// @@ -23552,7 +23905,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 474: + /// Semantic action for production 480: /// /// `RangeListList /* Vec::Push */: Comma RangeItem RangeListList;` /// @@ -23578,7 +23931,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 475: + /// Semantic action for production 481: /// /// `RangeListList /* Vec::New */: ;` /// @@ -23591,7 +23944,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 476: + /// Semantic action for production 482: /// /// `RangeListOpt /* Option::Some */: Comma;` /// @@ -23607,7 +23960,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 477: + /// Semantic action for production 483: /// /// `RangeListOpt /* Option::None */: ;` /// @@ -23619,7 +23972,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 478: + /// Semantic action for production 484: /// /// `RangeItem: Range;` /// @@ -23637,7 +23990,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 479: + /// Semantic action for production 485: /// /// `Select: LBracket Expression SelectOpt /* Option */ RBracket;` /// @@ -23667,7 +24020,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 480: + /// Semantic action for production 486: /// /// `SelectOpt /* Option::Some */: SelectOperator Expression;` /// @@ -23689,7 +24042,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 481: + /// Semantic action for production 487: /// /// `SelectOpt /* Option::None */: ;` /// @@ -23701,7 +24054,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 482: + /// Semantic action for production 488: /// /// `SelectOperator: Colon;` /// @@ -23721,7 +24074,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 483: + /// Semantic action for production 489: /// /// `SelectOperator: PlusColon;` /// @@ -23741,7 +24094,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 484: + /// Semantic action for production 490: /// /// `SelectOperator: MinusColon;` /// @@ -23761,7 +24114,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 485: + /// Semantic action for production 491: /// /// `SelectOperator: Step;` /// @@ -23781,7 +24134,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 486: + /// Semantic action for production 492: /// /// `Width: LAngle Expression WidthList /* Vec */ RAngle;` /// @@ -23811,7 +24164,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 487: + /// Semantic action for production 493: /// /// `WidthList /* Vec::Push */: Comma Expression WidthList;` /// @@ -23837,7 +24190,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 488: + /// Semantic action for production 494: /// /// `WidthList /* Vec::New */: ;` /// @@ -23850,7 +24203,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 489: + /// Semantic action for production 495: /// /// `Array: LBracket Expression ArrayList /* Vec */ RBracket;` /// @@ -23880,7 +24233,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 490: + /// Semantic action for production 496: /// /// `ArrayList /* Vec::Push */: Comma Expression ArrayList;` /// @@ -23906,7 +24259,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 491: + /// Semantic action for production 497: /// /// `ArrayList /* Vec::New */: ;` /// @@ -23919,7 +24272,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 492: + /// Semantic action for production 498: /// /// `Range: Expression RangeOpt /* Option */;` /// @@ -23943,7 +24296,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 493: + /// Semantic action for production 499: /// /// `RangeOpt /* Option::Some */: RangeOperator Expression;` /// @@ -23965,7 +24318,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 494: + /// Semantic action for production 500: /// /// `RangeOpt /* Option::None */: ;` /// @@ -23977,7 +24330,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 495: + /// Semantic action for production 501: /// /// `RangeOperator: DotDot;` /// @@ -23996,7 +24349,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 496: + /// Semantic action for production 502: /// /// `RangeOperator: DotDotEqu;` /// @@ -24015,7 +24368,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 497: + /// Semantic action for production 503: /// /// `FixedType: U32;` /// @@ -24032,7 +24385,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 498: + /// Semantic action for production 504: /// /// `FixedType: U64;` /// @@ -24049,7 +24402,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 499: + /// Semantic action for production 505: /// /// `FixedType: I32;` /// @@ -24066,7 +24419,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 500: + /// Semantic action for production 506: /// /// `FixedType: I64;` /// @@ -24083,7 +24436,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 501: + /// Semantic action for production 507: /// /// `FixedType: F32;` /// @@ -24100,7 +24453,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 502: + /// Semantic action for production 508: /// /// `FixedType: F64;` /// @@ -24117,7 +24470,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 503: + /// Semantic action for production 509: /// /// `FixedType: Strin;` /// @@ -24136,287 +24489,214 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 504: - /// - /// `VariableType: VariableTypeGroup VariableTypeOpt /* Option */;` - /// - #[parol_runtime::function_name::named] - fn variable_type( - &mut self, - _variable_type_group: &ParseTreeType<'t>, - _variable_type_opt: &ParseTreeType<'t>, - ) -> Result<()> { - let context = function_name!(); - trace!("{}", self.trace_item_stack(context)); - let variable_type_opt = pop_item!(self, variable_type_opt, VariableTypeOpt, context); - let variable_type_group = pop_item!(self, variable_type_group, VariableTypeGroup, context); - let variable_type_built = VariableType { - variable_type_group: Box::new(variable_type_group), - variable_type_opt, - }; - // Calling user action here - self.user_grammar.variable_type(&variable_type_built)?; - self.push(ASTType::VariableType(variable_type_built), context); - Ok(()) - } - - /// Semantic action for production 505: + /// Semantic action for production 510: /// - /// `VariableTypeGroup: Clock;` + /// `VariableType: Clock;` /// #[parol_runtime::function_name::named] - fn variable_type_group_0(&mut self, _clock: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_0(&mut self, _clock: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let clock = pop_item!(self, clock, Clock, context); - let variable_type_group_0_built = VariableTypeGroupClock { + let variable_type_0_built = VariableTypeClock { clock: Box::new(clock), }; - let variable_type_group_0_built = VariableTypeGroup::Clock(variable_type_group_0_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_0_built), - context, - ); + let variable_type_0_built = VariableType::Clock(variable_type_0_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_0_built)?; + self.push(ASTType::VariableType(variable_type_0_built), context); Ok(()) } - /// Semantic action for production 506: + /// Semantic action for production 511: /// - /// `VariableTypeGroup: ClockPosedge;` + /// `VariableType: ClockPosedge;` /// #[parol_runtime::function_name::named] - fn variable_type_group_1(&mut self, _clock_posedge: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_1(&mut self, _clock_posedge: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let clock_posedge = pop_item!(self, clock_posedge, ClockPosedge, context); - let variable_type_group_1_built = VariableTypeGroupClockPosedge { + let variable_type_1_built = VariableTypeClockPosedge { clock_posedge: Box::new(clock_posedge), }; - let variable_type_group_1_built = - VariableTypeGroup::ClockPosedge(variable_type_group_1_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_1_built), - context, - ); + let variable_type_1_built = VariableType::ClockPosedge(variable_type_1_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_1_built)?; + self.push(ASTType::VariableType(variable_type_1_built), context); Ok(()) } - /// Semantic action for production 507: + /// Semantic action for production 512: /// - /// `VariableTypeGroup: ClockNegedge;` + /// `VariableType: ClockNegedge;` /// #[parol_runtime::function_name::named] - fn variable_type_group_2(&mut self, _clock_negedge: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_2(&mut self, _clock_negedge: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let clock_negedge = pop_item!(self, clock_negedge, ClockNegedge, context); - let variable_type_group_2_built = VariableTypeGroupClockNegedge { + let variable_type_2_built = VariableTypeClockNegedge { clock_negedge: Box::new(clock_negedge), }; - let variable_type_group_2_built = - VariableTypeGroup::ClockNegedge(variable_type_group_2_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_2_built), - context, - ); + let variable_type_2_built = VariableType::ClockNegedge(variable_type_2_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_2_built)?; + self.push(ASTType::VariableType(variable_type_2_built), context); Ok(()) } - /// Semantic action for production 508: + /// Semantic action for production 513: /// - /// `VariableTypeGroup: Reset;` + /// `VariableType: Reset;` /// #[parol_runtime::function_name::named] - fn variable_type_group_3(&mut self, _reset: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_3(&mut self, _reset: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let reset = pop_item!(self, reset, Reset, context); - let variable_type_group_3_built = VariableTypeGroupReset { + let variable_type_3_built = VariableTypeReset { reset: Box::new(reset), }; - let variable_type_group_3_built = VariableTypeGroup::Reset(variable_type_group_3_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_3_built), - context, - ); + let variable_type_3_built = VariableType::Reset(variable_type_3_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_3_built)?; + self.push(ASTType::VariableType(variable_type_3_built), context); Ok(()) } - /// Semantic action for production 509: + /// Semantic action for production 514: /// - /// `VariableTypeGroup: ResetAsyncHigh;` + /// `VariableType: ResetAsyncHigh;` /// #[parol_runtime::function_name::named] - fn variable_type_group_4(&mut self, _reset_async_high: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_4(&mut self, _reset_async_high: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let reset_async_high = pop_item!(self, reset_async_high, ResetAsyncHigh, context); - let variable_type_group_4_built = VariableTypeGroupResetAsyncHigh { + let variable_type_4_built = VariableTypeResetAsyncHigh { reset_async_high: Box::new(reset_async_high), }; - let variable_type_group_4_built = - VariableTypeGroup::ResetAsyncHigh(variable_type_group_4_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_4_built), - context, - ); + let variable_type_4_built = VariableType::ResetAsyncHigh(variable_type_4_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_4_built)?; + self.push(ASTType::VariableType(variable_type_4_built), context); Ok(()) } - /// Semantic action for production 510: + /// Semantic action for production 515: /// - /// `VariableTypeGroup: ResetAsyncLow;` + /// `VariableType: ResetAsyncLow;` /// #[parol_runtime::function_name::named] - fn variable_type_group_5(&mut self, _reset_async_low: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_5(&mut self, _reset_async_low: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let reset_async_low = pop_item!(self, reset_async_low, ResetAsyncLow, context); - let variable_type_group_5_built = VariableTypeGroupResetAsyncLow { + let variable_type_5_built = VariableTypeResetAsyncLow { reset_async_low: Box::new(reset_async_low), }; - let variable_type_group_5_built = - VariableTypeGroup::ResetAsyncLow(variable_type_group_5_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_5_built), - context, - ); + let variable_type_5_built = VariableType::ResetAsyncLow(variable_type_5_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_5_built)?; + self.push(ASTType::VariableType(variable_type_5_built), context); Ok(()) } - /// Semantic action for production 511: + /// Semantic action for production 516: /// - /// `VariableTypeGroup: ResetSyncHigh;` + /// `VariableType: ResetSyncHigh;` /// #[parol_runtime::function_name::named] - fn variable_type_group_6(&mut self, _reset_sync_high: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_6(&mut self, _reset_sync_high: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let reset_sync_high = pop_item!(self, reset_sync_high, ResetSyncHigh, context); - let variable_type_group_6_built = VariableTypeGroupResetSyncHigh { + let variable_type_6_built = VariableTypeResetSyncHigh { reset_sync_high: Box::new(reset_sync_high), }; - let variable_type_group_6_built = - VariableTypeGroup::ResetSyncHigh(variable_type_group_6_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_6_built), - context, - ); + let variable_type_6_built = VariableType::ResetSyncHigh(variable_type_6_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_6_built)?; + self.push(ASTType::VariableType(variable_type_6_built), context); Ok(()) } - /// Semantic action for production 512: + /// Semantic action for production 517: /// - /// `VariableTypeGroup: ResetSyncLow;` + /// `VariableType: ResetSyncLow;` /// #[parol_runtime::function_name::named] - fn variable_type_group_7(&mut self, _reset_sync_low: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_7(&mut self, _reset_sync_low: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let reset_sync_low = pop_item!(self, reset_sync_low, ResetSyncLow, context); - let variable_type_group_7_built = VariableTypeGroupResetSyncLow { + let variable_type_7_built = VariableTypeResetSyncLow { reset_sync_low: Box::new(reset_sync_low), }; - let variable_type_group_7_built = - VariableTypeGroup::ResetSyncLow(variable_type_group_7_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_7_built), - context, - ); + let variable_type_7_built = VariableType::ResetSyncLow(variable_type_7_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_7_built)?; + self.push(ASTType::VariableType(variable_type_7_built), context); Ok(()) } - /// Semantic action for production 513: + /// Semantic action for production 518: /// - /// `VariableTypeGroup: Logic;` + /// `VariableType: Logic;` /// #[parol_runtime::function_name::named] - fn variable_type_group_8(&mut self, _logic: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_8(&mut self, _logic: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let logic = pop_item!(self, logic, Logic, context); - let variable_type_group_8_built = VariableTypeGroupLogic { + let variable_type_8_built = VariableTypeLogic { logic: Box::new(logic), }; - let variable_type_group_8_built = VariableTypeGroup::Logic(variable_type_group_8_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_8_built), - context, - ); + let variable_type_8_built = VariableType::Logic(variable_type_8_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_8_built)?; + self.push(ASTType::VariableType(variable_type_8_built), context); Ok(()) } - /// Semantic action for production 514: + /// Semantic action for production 519: /// - /// `VariableTypeGroup: Bit;` + /// `VariableType: Bit;` /// #[parol_runtime::function_name::named] - fn variable_type_group_9(&mut self, _bit: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_9(&mut self, _bit: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let bit = pop_item!(self, bit, Bit, context); - let variable_type_group_9_built = VariableTypeGroupBit { bit: Box::new(bit) }; - let variable_type_group_9_built = VariableTypeGroup::Bit(variable_type_group_9_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_9_built), - context, - ); + let variable_type_9_built = VariableTypeBit { bit: Box::new(bit) }; + let variable_type_9_built = VariableType::Bit(variable_type_9_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_9_built)?; + self.push(ASTType::VariableType(variable_type_9_built), context); Ok(()) } - /// Semantic action for production 515: + /// Semantic action for production 520: /// - /// `VariableTypeGroup: ScopedIdentifier;` + /// `VariableType: ScopedIdentifier;` /// #[parol_runtime::function_name::named] - fn variable_type_group_10(&mut self, _scoped_identifier: &ParseTreeType<'t>) -> Result<()> { + fn variable_type_10(&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 variable_type_group_10_built = VariableTypeGroupScopedIdentifier { + let variable_type_10_built = VariableTypeScopedIdentifier { scoped_identifier: Box::new(scoped_identifier), }; - let variable_type_group_10_built = - VariableTypeGroup::ScopedIdentifier(variable_type_group_10_built); - self.push( - ASTType::VariableTypeGroup(variable_type_group_10_built), - context, - ); - Ok(()) - } - - /// Semantic action for production 516: - /// - /// `VariableTypeOpt /* Option::Some */: Width;` - /// - #[parol_runtime::function_name::named] - fn variable_type_opt_0(&mut self, _width: &ParseTreeType<'t>) -> Result<()> { - let context = function_name!(); - trace!("{}", self.trace_item_stack(context)); - let width = pop_item!(self, width, Width, context); - let variable_type_opt_0_built = VariableTypeOpt { - width: Box::new(width), - }; - self.push( - ASTType::VariableTypeOpt(Some(variable_type_opt_0_built)), - context, - ); - Ok(()) - } - - /// Semantic action for production 517: - /// - /// `VariableTypeOpt /* Option::None */: ;` - /// - #[parol_runtime::function_name::named] - fn variable_type_opt_1(&mut self) -> Result<()> { - let context = function_name!(); - trace!("{}", self.trace_item_stack(context)); - self.push(ASTType::VariableTypeOpt(None), context); + let variable_type_10_built = VariableType::ScopedIdentifier(variable_type_10_built); + // Calling user action here + self.user_grammar.variable_type(&variable_type_10_built)?; + self.push(ASTType::VariableType(variable_type_10_built), context); Ok(()) } - /// Semantic action for production 518: + /// Semantic action for production 521: /// /// `TypeModifier: Tri;` /// @@ -24433,7 +24713,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 519: + /// Semantic action for production 522: /// /// `TypeModifier: Signed;` /// @@ -24452,7 +24732,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 520: + /// Semantic action for production 523: /// /// `ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup;` /// @@ -24477,24 +24757,31 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 521: + /// Semantic action for production 524: /// - /// `ScalarTypeGroup: VariableType;` + /// `ScalarTypeGroup: VariableType ScalarTypeOpt /* Option */;` /// #[parol_runtime::function_name::named] - fn scalar_type_group_0(&mut self, _variable_type: &ParseTreeType<'t>) -> Result<()> { + fn scalar_type_group_0( + &mut self, + _variable_type: &ParseTreeType<'t>, + _scalar_type_opt: &ParseTreeType<'t>, + ) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); + let scalar_type_opt = pop_item!(self, scalar_type_opt, ScalarTypeOpt, context); let variable_type = pop_item!(self, variable_type, VariableType, context); - let scalar_type_group_0_built = ScalarTypeGroupVariableType { + let scalar_type_group_0_built = ScalarTypeGroupVariableTypeScalarTypeOpt { variable_type: Box::new(variable_type), + scalar_type_opt, }; - let scalar_type_group_0_built = ScalarTypeGroup::VariableType(scalar_type_group_0_built); + let scalar_type_group_0_built = + ScalarTypeGroup::VariableTypeScalarTypeOpt(scalar_type_group_0_built); self.push(ASTType::ScalarTypeGroup(scalar_type_group_0_built), context); Ok(()) } - /// Semantic action for production 522: + /// Semantic action for production 525: /// /// `ScalarTypeGroup: FixedType;` /// @@ -24511,7 +24798,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 523: + /// Semantic action for production 526: /// /// `ScalarTypeList /* Vec::Push */: TypeModifier ScalarTypeList;` /// @@ -24534,7 +24821,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 524: + /// Semantic action for production 527: /// /// `ScalarTypeList /* Vec::New */: ;` /// @@ -24547,7 +24834,38 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 525: + /// Semantic action for production 528: + /// + /// `ScalarTypeOpt /* Option::Some */: Width;` + /// + #[parol_runtime::function_name::named] + fn scalar_type_opt_0(&mut self, _width: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let width = pop_item!(self, width, Width, context); + let scalar_type_opt_0_built = ScalarTypeOpt { + width: Box::new(width), + }; + self.push( + ASTType::ScalarTypeOpt(Some(scalar_type_opt_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 529: + /// + /// `ScalarTypeOpt /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn scalar_type_opt_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ScalarTypeOpt(None), context); + Ok(()) + } + + /// Semantic action for production 530: /// /// `ArrayType: ScalarType ArrayTypeOpt /* Option */;` /// @@ -24571,7 +24889,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 526: + /// Semantic action for production 531: /// /// `ArrayTypeOpt /* Option::Some */: Array;` /// @@ -24587,7 +24905,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 527: + /// Semantic action for production 532: /// /// `ArrayTypeOpt /* Option::None */: ;` /// @@ -24599,7 +24917,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 528: + /// Semantic action for production 533: /// /// `CastingType: U32;` /// @@ -24616,7 +24934,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 529: + /// Semantic action for production 534: /// /// `CastingType: U64;` /// @@ -24633,7 +24951,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 530: + /// Semantic action for production 535: /// /// `CastingType: I32;` /// @@ -24650,7 +24968,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 531: + /// Semantic action for production 536: /// /// `CastingType: I64;` /// @@ -24667,7 +24985,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 532: + /// Semantic action for production 537: /// /// `CastingType: F32;` /// @@ -24684,7 +25002,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 533: + /// Semantic action for production 538: /// /// `CastingType: F64;` /// @@ -24701,7 +25019,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 534: + /// Semantic action for production 539: /// /// `CastingType: Clock;` /// @@ -24720,7 +25038,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 535: + /// Semantic action for production 540: /// /// `CastingType: ClockPosedge;` /// @@ -24739,7 +25057,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 536: + /// Semantic action for production 541: /// /// `CastingType: ClockNegedge;` /// @@ -24758,7 +25076,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 537: + /// Semantic action for production 542: /// /// `CastingType: Reset;` /// @@ -24777,7 +25095,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 538: + /// Semantic action for production 543: /// /// `CastingType: ResetAsyncHigh;` /// @@ -24796,7 +25114,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 539: + /// Semantic action for production 544: /// /// `CastingType: ResetAsyncLow;` /// @@ -24815,7 +25133,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 540: + /// Semantic action for production 545: /// /// `CastingType: ResetSyncHigh;` /// @@ -24834,7 +25152,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 541: + /// Semantic action for production 546: /// /// `CastingType: ResetSyncLow;` /// @@ -24853,7 +25171,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 542: + /// Semantic action for production 547: /// /// `CastingType: ScopedIdentifier;` /// @@ -24872,7 +25190,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 543: + /// Semantic action for production 548: /// /// `ClockDomain: BackQuote Identifier;` /// @@ -24896,7 +25214,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 544: + /// Semantic action for production 549: /// /// `Statement: LetStatement;` /// @@ -24915,7 +25233,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 545: + /// Semantic action for production 550: /// /// `Statement: IdentifierStatement;` /// @@ -24935,7 +25253,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 546: + /// Semantic action for production 551: /// /// `Statement: IfStatement;` /// @@ -24954,7 +25272,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 547: + /// Semantic action for production 552: /// /// `Statement: IfResetStatement;` /// @@ -24973,7 +25291,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 548: + /// Semantic action for production 553: /// /// `Statement: ReturnStatement;` /// @@ -24992,7 +25310,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 549: + /// Semantic action for production 554: /// /// `Statement: BreakStatement;` /// @@ -25011,7 +25329,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 550: + /// Semantic action for production 555: /// /// `Statement: ForStatement;` /// @@ -25030,7 +25348,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 551: + /// Semantic action for production 556: /// /// `Statement: CaseStatement;` /// @@ -25049,7 +25367,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 552: + /// Semantic action for production 557: /// /// `Statement: SwitchStatement;` /// @@ -25068,7 +25386,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 553: + /// Semantic action for production 558: /// /// `LetStatement: Let Identifier Colon LetStatementOpt /* Option */ ArrayType Equ Expression Semicolon;` /// @@ -25110,7 +25428,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 554: + /// Semantic action for production 559: /// /// `LetStatementOpt /* Option::Some */: ClockDomain;` /// @@ -25129,7 +25447,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 555: + /// Semantic action for production 560: /// /// `LetStatementOpt /* Option::None */: ;` /// @@ -25141,7 +25459,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 556: + /// Semantic action for production 561: /// /// `IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon;` /// @@ -25178,7 +25496,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 557: + /// Semantic action for production 562: /// /// `IdentifierStatementGroup: FunctionCall;` /// @@ -25199,7 +25517,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 558: + /// Semantic action for production 563: /// /// `IdentifierStatementGroup: Assignment;` /// @@ -25220,7 +25538,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 559: + /// Semantic action for production 564: /// /// `Assignment: AssignmentGroup Expression;` /// @@ -25244,7 +25562,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 560: + /// Semantic action for production 565: /// /// `AssignmentGroup: Equ;` /// @@ -25259,7 +25577,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 561: + /// Semantic action for production 566: /// /// `AssignmentGroup: AssignmentOperator;` /// @@ -25277,7 +25595,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 562: + /// Semantic action for production 567: /// /// `IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */;` /// @@ -25318,7 +25636,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 563: + /// Semantic action for production 568: /// /// `IfStatementList0 /* Vec::Push */: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0;` /// @@ -25357,7 +25675,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 564: + /// Semantic action for production 569: /// /// `IfStatementList0List /* Vec::Push */: Statement IfStatementList0List;` /// @@ -25384,7 +25702,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 565: + /// Semantic action for production 570: /// /// `IfStatementList0List /* Vec::New */: ;` /// @@ -25400,7 +25718,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 566: + /// Semantic action for production 571: /// /// `IfStatementList0 /* Vec::New */: ;` /// @@ -25416,7 +25734,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 567: + /// Semantic action for production 572: /// /// `IfStatementList /* Vec::Push */: Statement IfStatementList;` /// @@ -25439,7 +25757,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 568: + /// Semantic action for production 573: /// /// `IfStatementList /* Vec::New */: ;` /// @@ -25452,7 +25770,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 569: + /// Semantic action for production 574: /// /// `IfStatementOpt /* Option::Some */: Else LBrace IfStatementOptList /* Vec */ RBrace;` /// @@ -25484,7 +25802,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 570: + /// Semantic action for production 575: /// /// `IfStatementOptList /* Vec::Push */: Statement IfStatementOptList;` /// @@ -25508,7 +25826,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 571: + /// Semantic action for production 576: /// /// `IfStatementOptList /* Vec::New */: ;` /// @@ -25524,7 +25842,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 572: + /// Semantic action for production 577: /// /// `IfStatementOpt /* Option::None */: ;` /// @@ -25536,7 +25854,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 573: + /// Semantic action for production 578: /// /// `IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */;` /// @@ -25580,7 +25898,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 574: + /// Semantic action for production 579: /// /// `IfResetStatementList0 /* Vec::Push */: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0;` /// @@ -25631,7 +25949,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 575: + /// Semantic action for production 580: /// /// `IfResetStatementList0List /* Vec::Push */: Statement IfResetStatementList0List;` /// @@ -25662,7 +25980,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 576: + /// Semantic action for production 581: /// /// `IfResetStatementList0List /* Vec::New */: ;` /// @@ -25678,7 +25996,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 577: + /// Semantic action for production 582: /// /// `IfResetStatementList0 /* Vec::New */: ;` /// @@ -25694,7 +26012,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 578: + /// Semantic action for production 583: /// /// `IfResetStatementList /* Vec::Push */: Statement IfResetStatementList;` /// @@ -25721,7 +26039,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 579: + /// Semantic action for production 584: /// /// `IfResetStatementList /* Vec::New */: ;` /// @@ -25737,7 +26055,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 580: + /// Semantic action for production 585: /// /// `IfResetStatementOpt /* Option::Some */: Else LBrace IfResetStatementOptList /* Vec */ RBrace;` /// @@ -25773,7 +26091,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 581: + /// Semantic action for production 586: /// /// `IfResetStatementOptList /* Vec::Push */: Statement IfResetStatementOptList;` /// @@ -25804,7 +26122,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 582: + /// Semantic action for production 587: /// /// `IfResetStatementOptList /* Vec::New */: ;` /// @@ -25820,7 +26138,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 583: + /// Semantic action for production 588: /// /// `IfResetStatementOpt /* Option::None */: ;` /// @@ -25832,7 +26150,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 584: + /// Semantic action for production 589: /// /// `ReturnStatement: Return Expression Semicolon;` /// @@ -25860,7 +26178,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 585: + /// Semantic action for production 590: /// /// `BreakStatement: Break Semicolon;` /// @@ -25884,7 +26202,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 586: + /// Semantic action for production 591: /// /// `ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace;` /// @@ -25933,7 +26251,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 587: + /// Semantic action for production 592: /// /// `ForStatementList /* Vec::Push */: Statement ForStatementList;` /// @@ -25956,7 +26274,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 588: + /// Semantic action for production 593: /// /// `ForStatementList /* Vec::New */: ;` /// @@ -25972,7 +26290,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 589: + /// Semantic action for production 594: /// /// `ForStatementOpt /* Option::Some */: Step AssignmentOperator Expression;` /// @@ -26000,7 +26318,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 590: + /// Semantic action for production 595: /// /// `ForStatementOpt /* Option::None */: ;` /// @@ -26012,7 +26330,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 591: + /// Semantic action for production 596: /// /// `CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace;` /// @@ -26046,7 +26364,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 592: + /// Semantic action for production 597: /// /// `CaseStatementList /* Vec::Push */: CaseItem CaseStatementList;` /// @@ -26070,7 +26388,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 593: + /// Semantic action for production 598: /// /// `CaseStatementList /* Vec::New */: ;` /// @@ -26086,7 +26404,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 594: + /// Semantic action for production 599: /// /// `CaseItem: CaseItemGroup Colon CaseItemGroup0;` /// @@ -26113,7 +26431,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 595: + /// Semantic action for production 600: /// /// `CaseItemGroup0: Statement;` /// @@ -26130,7 +26448,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 596: + /// Semantic action for production 601: /// /// `CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace;` /// @@ -26158,7 +26476,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 597: + /// Semantic action for production 602: /// /// `CaseItemGroup0List /* Vec::Push */: Statement CaseItemGroup0List;` /// @@ -26182,7 +26500,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 598: + /// Semantic action for production 603: /// /// `CaseItemGroup0List /* Vec::New */: ;` /// @@ -26198,7 +26516,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 599: + /// Semantic action for production 604: /// /// `CaseItemGroup: CaseCondition;` /// @@ -26215,7 +26533,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 600: + /// Semantic action for production 605: /// /// `CaseItemGroup: Defaul;` /// @@ -26232,7 +26550,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 601: + /// Semantic action for production 606: /// /// `CaseCondition: RangeItem CaseConditionList /* Vec */;` /// @@ -26257,7 +26575,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 602: + /// Semantic action for production 607: /// /// `CaseConditionList /* Vec::Push */: Comma RangeItem CaseConditionList;` /// @@ -26284,7 +26602,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 603: + /// Semantic action for production 608: /// /// `CaseConditionList /* Vec::New */: ;` /// @@ -26300,7 +26618,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 604: + /// Semantic action for production 609: /// /// `SwitchStatement: Switch LBrace SwitchStatementList /* Vec */ RBrace;` /// @@ -26332,7 +26650,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 605: + /// Semantic action for production 610: /// /// `SwitchStatementList /* Vec::Push */: SwitchItem SwitchStatementList;` /// @@ -26356,7 +26674,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 606: + /// Semantic action for production 611: /// /// `SwitchStatementList /* Vec::New */: ;` /// @@ -26372,7 +26690,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 607: + /// Semantic action for production 612: /// /// `SwitchItem: SwitchItemGroup Colon SwitchItemGroup0;` /// @@ -26399,7 +26717,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 608: + /// Semantic action for production 613: /// /// `SwitchItemGroup0: Statement;` /// @@ -26419,7 +26737,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 609: + /// Semantic action for production 614: /// /// `SwitchItemGroup0: LBrace SwitchItemGroup0List /* Vec */ RBrace;` /// @@ -26450,7 +26768,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 610: + /// Semantic action for production 615: /// /// `SwitchItemGroup0List /* Vec::Push */: Statement SwitchItemGroup0List;` /// @@ -26477,7 +26795,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 611: + /// Semantic action for production 616: /// /// `SwitchItemGroup0List /* Vec::New */: ;` /// @@ -26493,7 +26811,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 612: + /// Semantic action for production 617: /// /// `SwitchItemGroup: SwitchCondition;` /// @@ -26510,7 +26828,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 613: + /// Semantic action for production 618: /// /// `SwitchItemGroup: Defaul;` /// @@ -26527,7 +26845,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 614: + /// Semantic action for production 619: /// /// `SwitchCondition: Expression SwitchConditionList /* Vec */;` /// @@ -26553,7 +26871,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 615: + /// Semantic action for production 620: /// /// `SwitchConditionList /* Vec::Push */: Comma Expression SwitchConditionList;` /// @@ -26580,7 +26898,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 616: + /// Semantic action for production 621: /// /// `SwitchConditionList /* Vec::New */: ;` /// @@ -26596,7 +26914,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 617: + /// Semantic action for production 622: /// /// `Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket;` /// @@ -26629,7 +26947,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 618: + /// Semantic action for production 623: /// /// `AttributeOpt /* Option::Some */: LParen AttributeList RParen;` /// @@ -26654,7 +26972,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 619: + /// Semantic action for production 624: /// /// `AttributeOpt /* Option::None */: ;` /// @@ -26666,7 +26984,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 620: + /// Semantic action for production 625: /// /// `AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */;` /// @@ -26694,7 +27012,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 621: + /// Semantic action for production 626: /// /// `AttributeListList /* Vec::Push */: Comma AttributeItem AttributeListList;` /// @@ -26721,7 +27039,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 622: + /// Semantic action for production 627: /// /// `AttributeListList /* Vec::New */: ;` /// @@ -26737,7 +27055,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 623: + /// Semantic action for production 628: /// /// `AttributeListOpt /* Option::Some */: Comma;` /// @@ -26756,7 +27074,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 624: + /// Semantic action for production 629: /// /// `AttributeListOpt /* Option::None */: ;` /// @@ -26768,7 +27086,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 625: + /// Semantic action for production 630: /// /// `AttributeItem: Identifier;` /// @@ -26787,7 +27105,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 626: + /// Semantic action for production 631: /// /// `AttributeItem: StringLiteral;` /// @@ -26806,7 +27124,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 627: + /// Semantic action for production 632: /// /// `LetDeclaration: Let Identifier Colon LetDeclarationOpt /* Option */ ArrayType Equ Expression Semicolon;` /// @@ -26848,7 +27166,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 628: + /// Semantic action for production 633: /// /// `LetDeclarationOpt /* Option::Some */: ClockDomain;` /// @@ -26867,7 +27185,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 629: + /// Semantic action for production 634: /// /// `LetDeclarationOpt /* Option::None */: ;` /// @@ -26879,7 +27197,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 630: + /// Semantic action for production 635: /// /// `VarDeclaration: Var Identifier Colon VarDeclarationOpt /* Option */ ArrayType Semicolon;` /// @@ -26915,7 +27233,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 631: + /// Semantic action for production 636: /// /// `VarDeclarationOpt /* Option::Some */: ClockDomain;` /// @@ -26934,7 +27252,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 632: + /// Semantic action for production 637: /// /// `VarDeclarationOpt /* Option::None */: ;` /// @@ -26946,7 +27264,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 633: + /// Semantic action for production 638: /// /// `LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon;` /// @@ -26985,7 +27303,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 634: + /// Semantic action for production 639: /// /// `LocalDeclarationGroup: ArrayType Equ Expression;` /// @@ -27015,7 +27333,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 635: + /// Semantic action for production 640: /// /// `LocalDeclarationGroup: Type Equ TypeExpression;` /// @@ -27045,7 +27363,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 636: + /// Semantic action for production 641: /// /// `TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon;` /// @@ -27082,7 +27400,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 637: + /// Semantic action for production 642: /// /// `AlwaysFfDeclaration: AlwaysFf AlwaysFfDeclarationOpt /* Option */ LBrace AlwaysFfDeclarationList /* Vec */ RBrace;` /// @@ -27129,7 +27447,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 638: + /// Semantic action for production 643: /// /// `AlwaysFfDeclarationList /* Vec::Push */: Statement AlwaysFfDeclarationList;` /// @@ -27160,7 +27478,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 639: + /// Semantic action for production 644: /// /// `AlwaysFfDeclarationList /* Vec::New */: ;` /// @@ -27176,7 +27494,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 640: + /// Semantic action for production 645: /// /// `AlwaysFfDeclarationOpt /* Option::Some */: AlwayfFfEventList;` /// @@ -27199,7 +27517,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 641: + /// Semantic action for production 646: /// /// `AlwaysFfDeclarationOpt /* Option::None */: ;` /// @@ -27211,7 +27529,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 642: + /// Semantic action for production 647: /// /// `AlwayfFfEventList: LParen AlwaysFfClock AlwayfFfEventListOpt /* Option */ RParen;` /// @@ -27250,7 +27568,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 643: + /// Semantic action for production 648: /// /// `AlwayfFfEventListOpt /* Option::Some */: Comma AlwaysFfReset;` /// @@ -27275,7 +27593,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 644: + /// Semantic action for production 649: /// /// `AlwayfFfEventListOpt /* Option::None */: ;` /// @@ -27287,7 +27605,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 645: + /// Semantic action for production 650: /// /// `AlwaysFfClock: HierarchicalIdentifier;` /// @@ -27310,7 +27628,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 646: + /// Semantic action for production 651: /// /// `AlwaysFfReset: HierarchicalIdentifier;` /// @@ -27333,7 +27651,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 647: + /// Semantic action for production 652: /// /// `AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace;` /// @@ -27372,7 +27690,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 648: + /// Semantic action for production 653: /// /// `AlwaysCombDeclarationList /* Vec::Push */: Statement AlwaysCombDeclarationList;` /// @@ -27403,7 +27721,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 649: + /// Semantic action for production 654: /// /// `AlwaysCombDeclarationList /* Vec::New */: ;` /// @@ -27419,7 +27737,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 650: + /// Semantic action for production 655: /// /// `AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon;` /// @@ -27461,7 +27779,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 651: + /// Semantic action for production 656: /// /// `ModportDeclaration: Modport Identifier LBrace ModportList RBrace;` /// @@ -27498,7 +27816,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 652: + /// Semantic action for production 657: /// /// `ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */;` /// @@ -27526,7 +27844,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 653: + /// Semantic action for production 658: /// /// `ModportListList /* Vec::Push */: Comma ModportGroup ModportListList;` /// @@ -27552,7 +27870,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 654: + /// Semantic action for production 659: /// /// `ModportListList /* Vec::New */: ;` /// @@ -27565,7 +27883,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 655: + /// Semantic action for production 660: /// /// `ModportListOpt /* Option::Some */: Comma;` /// @@ -27584,7 +27902,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 656: + /// Semantic action for production 661: /// /// `ModportListOpt /* Option::None */: ;` /// @@ -27596,7 +27914,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 657: + /// Semantic action for production 662: /// /// `ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup;` /// @@ -27621,7 +27939,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 658: + /// Semantic action for production 663: /// /// `ModportGroupGroup: LBrace ModportList RBrace;` /// @@ -27651,7 +27969,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 659: + /// Semantic action for production 664: /// /// `ModportGroupGroup: ModportItem;` /// @@ -27672,7 +27990,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 660: + /// Semantic action for production 665: /// /// `ModportGroupList /* Vec::Push */: Attribute ModportGroupList;` /// @@ -27695,7 +28013,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 661: + /// Semantic action for production 666: /// /// `ModportGroupList /* Vec::New */: ;` /// @@ -27711,7 +28029,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 662: + /// Semantic action for production 667: /// /// `ModportItem: Identifier Colon Direction;` /// @@ -27738,7 +28056,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 663: + /// Semantic action for production 668: /// /// `EnumDeclaration: Enum Identifier EnumDeclarationOpt /* Option */ LBrace EnumList RBrace;` /// @@ -27776,7 +28094,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 664: + /// Semantic action for production 669: /// /// `EnumDeclarationOpt /* Option::Some */: Colon ScalarType;` /// @@ -27801,7 +28119,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 665: + /// Semantic action for production 670: /// /// `EnumDeclarationOpt /* Option::None */: ;` /// @@ -27813,7 +28131,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 666: + /// Semantic action for production 671: /// /// `EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */;` /// @@ -27840,7 +28158,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 667: + /// Semantic action for production 672: /// /// `EnumListList /* Vec::Push */: Comma EnumGroup EnumListList;` /// @@ -27866,7 +28184,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 668: + /// Semantic action for production 673: /// /// `EnumListList /* Vec::New */: ;` /// @@ -27879,7 +28197,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 669: + /// Semantic action for production 674: /// /// `EnumListOpt /* Option::Some */: Comma;` /// @@ -27895,7 +28213,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 670: + /// Semantic action for production 675: /// /// `EnumListOpt /* Option::None */: ;` /// @@ -27907,7 +28225,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 671: + /// Semantic action for production 676: /// /// `EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup;` /// @@ -27931,7 +28249,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 672: + /// Semantic action for production 677: /// /// `EnumGroupGroup: LBrace EnumList RBrace;` /// @@ -27958,7 +28276,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 673: + /// Semantic action for production 678: /// /// `EnumGroupGroup: EnumItem;` /// @@ -27975,7 +28293,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 674: + /// Semantic action for production 679: /// /// `EnumGroupList /* Vec::Push */: Attribute EnumGroupList;` /// @@ -27998,7 +28316,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 675: + /// Semantic action for production 680: /// /// `EnumGroupList /* Vec::New */: ;` /// @@ -28011,7 +28329,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 676: + /// Semantic action for production 681: /// /// `EnumItem: Identifier EnumItemOpt /* Option */;` /// @@ -28035,7 +28353,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 677: + /// Semantic action for production 682: /// /// `EnumItemOpt /* Option::Some */: Equ Expression;` /// @@ -28057,7 +28375,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 678: + /// Semantic action for production 683: /// /// `EnumItemOpt /* Option::None */: ;` /// @@ -28069,7 +28387,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 679: + /// Semantic action for production 684: /// /// `StructUnion: Struct;` /// @@ -28088,7 +28406,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 680: + /// Semantic action for production 685: /// /// `StructUnion: Union;` /// @@ -28107,7 +28425,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 681: + /// Semantic action for production 686: /// /// `StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace;` /// @@ -28152,7 +28470,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 682: + /// Semantic action for production 687: /// /// `StructUnionDeclarationOpt /* Option::Some */: WithGenericParameter;` /// @@ -28175,7 +28493,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 683: + /// Semantic action for production 688: /// /// `StructUnionDeclarationOpt /* Option::None */: ;` /// @@ -28187,7 +28505,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 684: + /// Semantic action for production 689: /// /// `StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */;` /// @@ -28217,7 +28535,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 685: + /// Semantic action for production 690: /// /// `StructUnionListList /* Vec::Push */: Comma StructUnionGroup StructUnionListList;` /// @@ -28247,7 +28565,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 686: + /// Semantic action for production 691: /// /// `StructUnionListList /* Vec::New */: ;` /// @@ -28263,7 +28581,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 687: + /// Semantic action for production 692: /// /// `StructUnionListOpt /* Option::Some */: Comma;` /// @@ -28282,7 +28600,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 688: + /// Semantic action for production 693: /// /// `StructUnionListOpt /* Option::None */: ;` /// @@ -28294,7 +28612,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 689: + /// Semantic action for production 694: /// /// `StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup;` /// @@ -28325,7 +28643,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 690: + /// Semantic action for production 695: /// /// `StructUnionGroupGroup: LBrace StructUnionList RBrace;` /// @@ -28355,7 +28673,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 691: + /// Semantic action for production 696: /// /// `StructUnionGroupGroup: StructUnionItem;` /// @@ -28376,7 +28694,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 692: + /// Semantic action for production 697: /// /// `StructUnionGroupList /* Vec::Push */: Attribute StructUnionGroupList;` /// @@ -28403,7 +28721,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 693: + /// Semantic action for production 698: /// /// `StructUnionGroupList /* Vec::New */: ;` /// @@ -28419,7 +28737,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 694: + /// Semantic action for production 699: /// /// `StructUnionItem: Identifier Colon ScalarType;` /// @@ -28447,7 +28765,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 695: + /// Semantic action for production 700: /// /// `InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace;` /// @@ -28486,7 +28804,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 696: + /// Semantic action for production 701: /// /// `InitialDeclarationList /* Vec::Push */: Statement InitialDeclarationList;` /// @@ -28517,7 +28835,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 697: + /// Semantic action for production 702: /// /// `InitialDeclarationList /* Vec::New */: ;` /// @@ -28533,7 +28851,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 698: + /// Semantic action for production 703: /// /// `FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace;` /// @@ -28565,7 +28883,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 699: + /// Semantic action for production 704: /// /// `FinalDeclarationList /* Vec::Push */: Statement FinalDeclarationList;` /// @@ -28592,7 +28910,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 700: + /// Semantic action for production 705: /// /// `FinalDeclarationList /* Vec::New */: ;` /// @@ -28608,7 +28926,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 701: + /// Semantic action for production 706: /// /// `InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon;` /// @@ -28654,7 +28972,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 702: + /// Semantic action for production 707: /// /// `InstDeclarationOpt1 /* Option::Some */: LParen InstDeclarationOpt2 /* Option */ RParen;` /// @@ -28683,7 +29001,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 703: + /// Semantic action for production 708: /// /// `InstDeclarationOpt2 /* Option::Some */: InstPortList;` /// @@ -28702,7 +29020,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 704: + /// Semantic action for production 709: /// /// `InstDeclarationOpt2 /* Option::None */: ;` /// @@ -28714,7 +29032,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 705: + /// Semantic action for production 710: /// /// `InstDeclarationOpt1 /* Option::None */: ;` /// @@ -28726,7 +29044,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 706: + /// Semantic action for production 711: /// /// `InstDeclarationOpt0 /* Option::Some */: InstParameter;` /// @@ -28745,7 +29063,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 707: + /// Semantic action for production 712: /// /// `InstDeclarationOpt0 /* Option::None */: ;` /// @@ -28757,7 +29075,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 708: + /// Semantic action for production 713: /// /// `InstDeclarationOpt /* Option::Some */: Array;` /// @@ -28776,7 +29094,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 709: + /// Semantic action for production 714: /// /// `InstDeclarationOpt /* Option::None */: ;` /// @@ -28788,7 +29106,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 710: + /// Semantic action for production 715: /// /// `InstParameter: Hash LParen InstParameterOpt /* Option */ RParen;` /// @@ -28818,7 +29136,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 711: + /// Semantic action for production 716: /// /// `InstParameterOpt /* Option::Some */: InstParameterList;` /// @@ -28837,7 +29155,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 712: + /// Semantic action for production 717: /// /// `InstParameterOpt /* Option::None */: ;` /// @@ -28849,7 +29167,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 713: + /// Semantic action for production 718: /// /// `InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */;` /// @@ -28887,7 +29205,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 714: + /// Semantic action for production 719: /// /// `InstParameterListList /* Vec::Push */: Comma InstParameterGroup InstParameterListList;` /// @@ -28922,7 +29240,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 715: + /// Semantic action for production 720: /// /// `InstParameterListList /* Vec::New */: ;` /// @@ -28938,7 +29256,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 716: + /// Semantic action for production 721: /// /// `InstParameterListOpt /* Option::Some */: Comma;` /// @@ -28957,7 +29275,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 717: + /// Semantic action for production 722: /// /// `InstParameterListOpt /* Option::None */: ;` /// @@ -28969,7 +29287,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 718: + /// Semantic action for production 723: /// /// `InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup;` /// @@ -29007,7 +29325,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 719: + /// Semantic action for production 724: /// /// `InstParameterGroupGroup: LBrace InstParameterList RBrace;` /// @@ -29040,7 +29358,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 720: + /// Semantic action for production 725: /// /// `InstParameterGroupGroup: InstParameterItem;` /// @@ -29064,7 +29382,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 721: + /// Semantic action for production 726: /// /// `InstParameterGroupList /* Vec::Push */: Attribute InstParameterGroupList;` /// @@ -29095,7 +29413,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 722: + /// Semantic action for production 727: /// /// `InstParameterGroupList /* Vec::New */: ;` /// @@ -29111,7 +29429,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 723: + /// Semantic action for production 728: /// /// `InstParameterItem: Identifier InstParameterItemOpt /* Option */;` /// @@ -29140,7 +29458,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 724: + /// Semantic action for production 729: /// /// `InstParameterItemOpt /* Option::Some */: Colon Expression;` /// @@ -29165,7 +29483,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 725: + /// Semantic action for production 730: /// /// `InstParameterItemOpt /* Option::None */: ;` /// @@ -29177,7 +29495,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 726: + /// Semantic action for production 731: /// /// `InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */;` /// @@ -29205,7 +29523,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 727: + /// Semantic action for production 732: /// /// `InstPortListList /* Vec::Push */: Comma InstPortGroup InstPortListList;` /// @@ -29232,7 +29550,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 728: + /// Semantic action for production 733: /// /// `InstPortListList /* Vec::New */: ;` /// @@ -29248,7 +29566,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 729: + /// Semantic action for production 734: /// /// `InstPortListOpt /* Option::Some */: Comma;` /// @@ -29267,7 +29585,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 730: + /// Semantic action for production 735: /// /// `InstPortListOpt /* Option::None */: ;` /// @@ -29279,7 +29597,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 731: + /// Semantic action for production 736: /// /// `InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup;` /// @@ -29305,7 +29623,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 732: + /// Semantic action for production 737: /// /// `InstPortGroupGroup: LBrace InstPortList RBrace;` /// @@ -29335,7 +29653,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 733: + /// Semantic action for production 738: /// /// `InstPortGroupGroup: InstPortItem;` /// @@ -29356,7 +29674,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 734: + /// Semantic action for production 739: /// /// `InstPortGroupList /* Vec::Push */: Attribute InstPortGroupList;` /// @@ -29380,7 +29698,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 735: + /// Semantic action for production 740: /// /// `InstPortGroupList /* Vec::New */: ;` /// @@ -29396,7 +29714,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 736: + /// Semantic action for production 741: /// /// `InstPortItem: Identifier InstPortItemOpt /* Option */;` /// @@ -29420,7 +29738,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 737: + /// Semantic action for production 742: /// /// `InstPortItemOpt /* Option::Some */: Colon Expression;` /// @@ -29445,7 +29763,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 738: + /// Semantic action for production 743: /// /// `InstPortItemOpt /* Option::None */: ;` /// @@ -29457,7 +29775,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 739: + /// Semantic action for production 744: /// /// `WithParameter: Hash LParen WithParameterOpt /* Option */ RParen;` /// @@ -29487,7 +29805,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 740: + /// Semantic action for production 745: /// /// `WithParameterOpt /* Option::Some */: WithParameterList;` /// @@ -29506,7 +29824,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 741: + /// Semantic action for production 746: /// /// `WithParameterOpt /* Option::None */: ;` /// @@ -29518,7 +29836,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 742: + /// Semantic action for production 747: /// /// `WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */;` /// @@ -29556,7 +29874,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 743: + /// Semantic action for production 748: /// /// `WithParameterListList /* Vec::Push */: Comma WithParameterGroup WithParameterListList;` /// @@ -29591,7 +29909,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 744: + /// Semantic action for production 749: /// /// `WithParameterListList /* Vec::New */: ;` /// @@ -29607,7 +29925,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 745: + /// Semantic action for production 750: /// /// `WithParameterListOpt /* Option::Some */: Comma;` /// @@ -29626,7 +29944,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 746: + /// Semantic action for production 751: /// /// `WithParameterListOpt /* Option::None */: ;` /// @@ -29638,7 +29956,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 747: + /// Semantic action for production 752: /// /// `WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup;` /// @@ -29676,7 +29994,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 748: + /// Semantic action for production 753: /// /// `WithParameterGroupGroup: LBrace WithParameterList RBrace;` /// @@ -29709,7 +30027,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 749: + /// Semantic action for production 754: /// /// `WithParameterGroupGroup: WithParameterItem;` /// @@ -29733,7 +30051,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 750: + /// Semantic action for production 755: /// /// `WithParameterGroupList /* Vec::Push */: Attribute WithParameterGroupList;` /// @@ -29764,7 +30082,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 751: + /// Semantic action for production 756: /// /// `WithParameterGroupList /* Vec::New */: ;` /// @@ -29780,7 +30098,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 752: + /// Semantic action for production 757: /// /// `WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0;` /// @@ -29824,7 +30142,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 753: + /// Semantic action for production 758: /// /// `WithParameterItemGroup0: ArrayType Equ Expression;` /// @@ -29854,7 +30172,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 754: + /// Semantic action for production 759: /// /// `WithParameterItemGroup0: Type Equ TypeExpression;` /// @@ -29884,7 +30202,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 755: + /// Semantic action for production 760: /// /// `WithParameterItemGroup: Param;` /// @@ -29905,7 +30223,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 756: + /// Semantic action for production 761: /// /// `WithParameterItemGroup: Local;` /// @@ -29926,7 +30244,64 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 757: + /// Semantic action for production 762: + /// + /// `GenericBound: Const;` + /// + #[parol_runtime::function_name::named] + fn generic_bound_0(&mut self, _const: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let r#const = pop_item!(self, r#const, Const, context); + let generic_bound_0_built = GenericBoundConst { + r#const: Box::new(r#const), + }; + let generic_bound_0_built = GenericBound::Const(generic_bound_0_built); + // Calling user action here + self.user_grammar.generic_bound(&generic_bound_0_built)?; + self.push(ASTType::GenericBound(generic_bound_0_built), context); + Ok(()) + } + + /// Semantic action for production 763: + /// + /// `GenericBound: Type;` + /// + #[parol_runtime::function_name::named] + fn generic_bound_1(&mut self, _type: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let r#type = pop_item!(self, r#type, Type, context); + let generic_bound_1_built = GenericBoundType { + r#type: Box::new(r#type), + }; + let generic_bound_1_built = GenericBound::Type(generic_bound_1_built); + // Calling user action here + self.user_grammar.generic_bound(&generic_bound_1_built)?; + self.push(ASTType::GenericBound(generic_bound_1_built), context); + Ok(()) + } + + /// Semantic action for production 764: + /// + /// `GenericBound: ScopedIdentifier;` + /// + #[parol_runtime::function_name::named] + fn generic_bound_2(&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 generic_bound_2_built = GenericBoundScopedIdentifier { + scoped_identifier: Box::new(scoped_identifier), + }; + let generic_bound_2_built = GenericBound::ScopedIdentifier(generic_bound_2_built); + // Calling user action here + self.user_grammar.generic_bound(&generic_bound_2_built)?; + self.push(ASTType::GenericBound(generic_bound_2_built), context); + Ok(()) + } + + /// Semantic action for production 765: /// /// `WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle;` /// @@ -29962,7 +30337,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 758: + /// Semantic action for production 766: /// /// `WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */;` /// @@ -30008,7 +30383,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 759: + /// Semantic action for production 767: /// /// `WithGenericParameterListList /* Vec::Push */: Comma WithGenericParameterItem WithGenericParameterListList;` /// @@ -30047,7 +30422,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 760: + /// Semantic action for production 768: /// /// `WithGenericParameterListList /* Vec::New */: ;` /// @@ -30063,7 +30438,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 761: + /// Semantic action for production 769: /// /// `WithGenericParameterListOpt /* Option::Some */: Comma;` /// @@ -30082,7 +30457,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 762: + /// Semantic action for production 770: /// /// `WithGenericParameterListOpt /* Option::None */: ;` /// @@ -30094,14 +30469,16 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 763: + /// Semantic action for production 771: /// - /// `WithGenericParameterItem: Identifier WithGenericParameterItemOpt /* Option */;` + /// `WithGenericParameterItem: Identifier Colon GenericBound WithGenericParameterItemOpt /* Option */;` /// #[parol_runtime::function_name::named] fn with_generic_parameter_item( &mut self, _identifier: &ParseTreeType<'t>, + _colon: &ParseTreeType<'t>, + _generic_bound: &ParseTreeType<'t>, _with_generic_parameter_item_opt: &ParseTreeType<'t>, ) -> Result<()> { let context = function_name!(); @@ -30112,9 +30489,13 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { WithGenericParameterItemOpt, context ); + let generic_bound = pop_item!(self, generic_bound, GenericBound, context); + let colon = pop_item!(self, colon, Colon, context); let identifier = pop_item!(self, identifier, Identifier, context); let with_generic_parameter_item_built = WithGenericParameterItem { identifier: Box::new(identifier), + colon: Box::new(colon), + generic_bound: Box::new(generic_bound), with_generic_parameter_item_opt, }; // Calling user action here @@ -30127,7 +30508,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 764: + /// Semantic action for production 772: /// /// `WithGenericParameterItemOpt /* Option::Some */: Equ WithGenericArgumentItem;` /// @@ -30157,7 +30538,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 765: + /// Semantic action for production 773: /// /// `WithGenericParameterItemOpt /* Option::None */: ;` /// @@ -30169,7 +30550,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 766: + /// Semantic action for production 774: /// /// `WithGenericArgument: ColonColonLAngle %push(Generic) WithGenericArgumentOpt /* Option */ RAngle %pop();` /// @@ -30205,7 +30586,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 767: + /// Semantic action for production 775: /// /// `WithGenericArgumentOpt /* Option::Some */: WithGenericArgumentList;` /// @@ -30232,7 +30613,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 768: + /// Semantic action for production 776: /// /// `WithGenericArgumentOpt /* Option::None */: ;` /// @@ -30244,7 +30625,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 769: + /// Semantic action for production 777: /// /// `WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */;` /// @@ -30290,7 +30671,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 770: + /// Semantic action for production 778: /// /// `WithGenericArgumentListList /* Vec::Push */: Comma WithGenericArgumentItem WithGenericArgumentListList;` /// @@ -30329,7 +30710,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 771: + /// Semantic action for production 779: /// /// `WithGenericArgumentListList /* Vec::New */: ;` /// @@ -30345,7 +30726,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 772: + /// Semantic action for production 780: /// /// `WithGenericArgumentListOpt /* Option::Some */: Comma;` /// @@ -30364,7 +30745,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 773: + /// Semantic action for production 781: /// /// `WithGenericArgumentListOpt /* Option::None */: ;` /// @@ -30376,7 +30757,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 774: + /// Semantic action for production 782: /// /// `WithGenericArgumentItem: ScopedIdentifier;` /// @@ -30403,7 +30784,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 775: + /// Semantic action for production 783: /// /// `WithGenericArgumentItem: Number;` /// @@ -30427,7 +30808,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 776: + /// Semantic action for production 784: /// /// `PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen;` /// @@ -30456,7 +30837,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 777: + /// Semantic action for production 785: /// /// `PortDeclarationOpt /* Option::Some */: PortDeclarationList;` /// @@ -30476,7 +30857,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 778: + /// Semantic action for production 786: /// /// `PortDeclarationOpt /* Option::None */: ;` /// @@ -30488,7 +30869,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 779: + /// Semantic action for production 787: /// /// `PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */;` /// @@ -30530,7 +30911,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 780: + /// Semantic action for production 788: /// /// `PortDeclarationListList /* Vec::Push */: Comma PortDeclarationGroup PortDeclarationListList;` /// @@ -30565,7 +30946,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 781: + /// Semantic action for production 789: /// /// `PortDeclarationListList /* Vec::New */: ;` /// @@ -30581,7 +30962,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 782: + /// Semantic action for production 790: /// /// `PortDeclarationListOpt /* Option::Some */: Comma;` /// @@ -30600,7 +30981,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 783: + /// Semantic action for production 791: /// /// `PortDeclarationListOpt /* Option::None */: ;` /// @@ -30612,7 +30993,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 784: + /// Semantic action for production 792: /// /// `PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup;` /// @@ -30650,7 +31031,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 785: + /// Semantic action for production 793: /// /// `PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace;` /// @@ -30684,7 +31065,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 786: + /// Semantic action for production 794: /// /// `PortDeclarationGroupGroup: PortDeclarationItem;` /// @@ -30709,7 +31090,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 787: + /// Semantic action for production 795: /// /// `PortDeclarationGroupList /* Vec::Push */: Attribute PortDeclarationGroupList;` /// @@ -30740,7 +31121,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 788: + /// Semantic action for production 796: /// /// `PortDeclarationGroupList /* Vec::New */: ;` /// @@ -30756,7 +31137,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 789: + /// Semantic action for production 797: /// /// `PortDeclarationItem: Identifier Colon PortDeclarationItemGroup;` /// @@ -30792,7 +31173,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 790: + /// Semantic action for production 798: /// /// `PortDeclarationItemGroup: PortTypeConcrete;` /// @@ -30816,7 +31197,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 791: + /// Semantic action for production 799: /// /// `PortDeclarationItemGroup: PortTypeAbstract;` /// @@ -30840,7 +31221,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 792: + /// Semantic action for production 800: /// /// `PortTypeConcrete: Direction PortTypeConcreteOpt /* Option */ ArrayType;` /// @@ -30869,7 +31250,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 793: + /// Semantic action for production 801: /// /// `PortTypeConcreteOpt /* Option::Some */: ClockDomain;` /// @@ -30888,7 +31269,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 794: + /// Semantic action for production 802: /// /// `PortTypeConcreteOpt /* Option::None */: ;` /// @@ -30900,7 +31281,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 795: + /// Semantic action for production 803: /// /// `PortTypeAbstract: PortTypeAbstractOpt /* Option */ Interface PortTypeAbstractOpt0 /* Option */;` /// @@ -30930,7 +31311,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 796: + /// Semantic action for production 804: /// /// `PortTypeAbstractOpt0 /* Option::Some */: Array;` /// @@ -30949,7 +31330,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 797: + /// Semantic action for production 805: /// /// `PortTypeAbstractOpt0 /* Option::None */: ;` /// @@ -30961,7 +31342,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 798: + /// Semantic action for production 806: /// /// `PortTypeAbstractOpt /* Option::Some */: ClockDomain;` /// @@ -30980,7 +31361,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 799: + /// Semantic action for production 807: /// /// `PortTypeAbstractOpt /* Option::None */: ;` /// @@ -30992,7 +31373,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 800: + /// Semantic action for production 808: /// /// `Direction: Input;` /// @@ -31011,7 +31392,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 801: + /// Semantic action for production 809: /// /// `Direction: Output;` /// @@ -31030,7 +31411,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 802: + /// Semantic action for production 810: /// /// `Direction: Inout;` /// @@ -31049,7 +31430,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 803: + /// Semantic action for production 811: /// /// `Direction: Ref;` /// @@ -31068,7 +31449,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 804: + /// Semantic action for production 812: /// /// `Direction: Modport;` /// @@ -31087,7 +31468,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 805: + /// Semantic action for production 813: /// /// `Direction: Import;` /// @@ -31106,7 +31487,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 806: + /// Semantic action for production 814: /// /// `FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace;` /// @@ -31172,7 +31553,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 807: + /// Semantic action for production 815: /// /// `FunctionDeclarationList /* Vec::Push */: FunctionItem FunctionDeclarationList;` /// @@ -31203,7 +31584,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 808: + /// Semantic action for production 816: /// /// `FunctionDeclarationList /* Vec::New */: ;` /// @@ -31219,7 +31600,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 809: + /// Semantic action for production 817: /// /// `FunctionDeclarationOpt1 /* Option::Some */: MinusGT ScalarType;` /// @@ -31244,7 +31625,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 810: + /// Semantic action for production 818: /// /// `FunctionDeclarationOpt1 /* Option::None */: ;` /// @@ -31256,7 +31637,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 811: + /// Semantic action for production 819: /// /// `FunctionDeclarationOpt0 /* Option::Some */: PortDeclaration;` /// @@ -31275,7 +31656,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 812: + /// Semantic action for production 820: /// /// `FunctionDeclarationOpt0 /* Option::None */: ;` /// @@ -31287,7 +31668,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 813: + /// Semantic action for production 821: /// /// `FunctionDeclarationOpt /* Option::Some */: WithGenericParameter;` /// @@ -31310,7 +31691,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 814: + /// Semantic action for production 822: /// /// `FunctionDeclarationOpt /* Option::None */: ;` /// @@ -31322,7 +31703,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 815: + /// Semantic action for production 823: /// /// `FunctionItem: VarDeclaration;` /// @@ -31341,7 +31722,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 816: + /// Semantic action for production 824: /// /// `FunctionItem: Statement;` /// @@ -31360,7 +31741,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 817: + /// Semantic action for production 825: /// /// `ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon;` /// @@ -31395,7 +31776,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 818: + /// Semantic action for production 826: /// /// `ImportDeclarationOpt /* Option::Some */: ColonColon Star;` /// @@ -31420,7 +31801,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 819: + /// Semantic action for production 827: /// /// `ImportDeclarationOpt /* Option::None */: ;` /// @@ -31432,7 +31813,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 820: + /// Semantic action for production 828: /// /// `ExportDeclaration: Export ExportDeclarationGroup Semicolon;` /// @@ -31468,7 +31849,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 821: + /// Semantic action for production 829: /// /// `ExportDeclarationGroup: Star;` /// @@ -31489,7 +31870,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 822: + /// Semantic action for production 830: /// /// `ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */;` /// @@ -31520,7 +31901,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 823: + /// Semantic action for production 831: /// /// `ExportDeclarationOpt /* Option::Some */: ColonColon Star;` /// @@ -31545,7 +31926,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 824: + /// Semantic action for production 832: /// /// `ExportDeclarationOpt /* Option::None */: ;` /// @@ -31557,7 +31938,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 825: + /// Semantic action for production 833: /// /// `UnsafeBlock: Unsafe LParen Identifier RParen LBrace UnsafeBlockList /* Vec */ RBrace;` /// @@ -31597,7 +31978,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 826: + /// Semantic action for production 834: /// /// `UnsafeBlockList /* Vec::Push */: ModuleGroup UnsafeBlockList;` /// @@ -31620,7 +32001,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 827: + /// Semantic action for production 835: /// /// `UnsafeBlockList /* Vec::New */: ;` /// @@ -31633,9 +32014,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 828: + /// Semantic action for production 836: /// - /// `ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace;` + /// `ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ ModuleDeclarationOpt3 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace;` /// #[parol_runtime::function_name::named] fn module_declaration( @@ -31646,6 +32027,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { _module_declaration_opt0: &ParseTreeType<'t>, _module_declaration_opt1: &ParseTreeType<'t>, _module_declaration_opt2: &ParseTreeType<'t>, + _module_declaration_opt3: &ParseTreeType<'t>, _l_brace: &ParseTreeType<'t>, _module_declaration_list: &ParseTreeType<'t>, _r_brace: &ParseTreeType<'t>, @@ -31660,6 +32042,12 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { context ); let l_brace = pop_item!(self, l_brace, LBrace, context); + let module_declaration_opt3 = pop_item!( + self, + module_declaration_opt3, + ModuleDeclarationOpt3, + context + ); let module_declaration_opt2 = pop_item!( self, module_declaration_opt2, @@ -31689,6 +32077,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { module_declaration_opt0, module_declaration_opt1, module_declaration_opt2, + module_declaration_opt3, l_brace: Box::new(l_brace), module_declaration_list, r_brace: Box::new(r_brace), @@ -31703,7 +32092,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 829: + /// Semantic action for production 837: /// /// `ModuleDeclarationList /* Vec::Push */: ModuleGroup ModuleDeclarationList;` /// @@ -31734,7 +32123,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 830: + /// Semantic action for production 838: /// /// `ModuleDeclarationList /* Vec::New */: ;` /// @@ -31750,18 +32139,49 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 831: + /// Semantic action for production 839: /// - /// `ModuleDeclarationOpt2 /* Option::Some */: PortDeclaration;` + /// `ModuleDeclarationOpt3 /* Option::Some */: PortDeclaration;` /// #[parol_runtime::function_name::named] - fn module_declaration_opt2_0(&mut self, _port_declaration: &ParseTreeType<'t>) -> Result<()> { + fn module_declaration_opt3_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_opt2_0_built = ModuleDeclarationOpt2 { + let module_declaration_opt3_0_built = ModuleDeclarationOpt3 { port_declaration: Box::new(port_declaration), }; + self.push( + ASTType::ModuleDeclarationOpt3(Some(module_declaration_opt3_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 840: + /// + /// `ModuleDeclarationOpt3 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn module_declaration_opt3_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ModuleDeclarationOpt3(None), context); + Ok(()) + } + + /// Semantic action for production 841: + /// + /// `ModuleDeclarationOpt2 /* Option::Some */: WithParameter;` + /// + #[parol_runtime::function_name::named] + fn module_declaration_opt2_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_opt2_0_built = ModuleDeclarationOpt2 { + with_parameter: Box::new(with_parameter), + }; self.push( ASTType::ModuleDeclarationOpt2(Some(module_declaration_opt2_0_built)), context, @@ -31769,7 +32189,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 832: + /// Semantic action for production 842: /// /// `ModuleDeclarationOpt2 /* Option::None */: ;` /// @@ -31781,17 +32201,23 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 833: + /// Semantic action for production 843: /// - /// `ModuleDeclarationOpt1 /* Option::Some */: WithParameter;` + /// `ModuleDeclarationOpt1 /* Option::Some */: For ScopedIdentifier;` /// #[parol_runtime::function_name::named] - fn module_declaration_opt1_0(&mut self, _with_parameter: &ParseTreeType<'t>) -> Result<()> { + fn module_declaration_opt1_0( + &mut self, + _for: &ParseTreeType<'t>, + _scoped_identifier: &ParseTreeType<'t>, + ) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); - let with_parameter = pop_item!(self, with_parameter, WithParameter, context); + let scoped_identifier = pop_item!(self, scoped_identifier, ScopedIdentifier, context); + let r#for = pop_item!(self, r#for, For, context); let module_declaration_opt1_0_built = ModuleDeclarationOpt1 { - with_parameter: Box::new(with_parameter), + r#for: Box::new(r#for), + scoped_identifier: Box::new(scoped_identifier), }; self.push( ASTType::ModuleDeclarationOpt1(Some(module_declaration_opt1_0_built)), @@ -31800,7 +32226,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 834: + /// Semantic action for production 844: /// /// `ModuleDeclarationOpt1 /* Option::None */: ;` /// @@ -31812,7 +32238,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 835: + /// Semantic action for production 845: /// /// `ModuleDeclarationOpt0 /* Option::Some */: WithGenericParameter;` /// @@ -31835,7 +32261,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 836: + /// Semantic action for production 846: /// /// `ModuleDeclarationOpt0 /* Option::None */: ;` /// @@ -31847,7 +32273,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 837: + /// Semantic action for production 847: /// /// `ModuleDeclarationOpt /* Option::Some */: Pub;` /// @@ -31866,7 +32292,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 838: + /// Semantic action for production 848: /// /// `ModuleDeclarationOpt /* Option::None */: ;` /// @@ -31878,7 +32304,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 839: + /// Semantic action for production 849: /// /// `ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */;` /// @@ -31925,7 +32351,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 840: + /// Semantic action for production 850: /// /// `ModuleIfDeclarationList /* Vec::Push */: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList;` /// @@ -31970,7 +32396,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 841: + /// Semantic action for production 851: /// /// `ModuleIfDeclarationList /* Vec::New */: ;` /// @@ -31986,7 +32412,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 842: + /// Semantic action for production 852: /// /// `ModuleIfDeclarationOpt /* Option::Some */: Else ModuleOptionalNamedBlock;` /// @@ -32016,7 +32442,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 843: + /// Semantic action for production 853: /// /// `ModuleIfDeclarationOpt /* Option::None */: ;` /// @@ -32028,7 +32454,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 844: + /// Semantic action for production 854: /// /// `ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock;` /// @@ -32073,7 +32499,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 845: + /// Semantic action for production 855: /// /// `ModuleForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression;` /// @@ -32101,7 +32527,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 846: + /// Semantic action for production 856: /// /// `ModuleForDeclarationOpt /* Option::None */: ;` /// @@ -32113,7 +32539,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 847: + /// Semantic action for production 857: /// /// `ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace;` /// @@ -32148,7 +32574,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 848: + /// Semantic action for production 858: /// /// `ModuleNamedBlockList /* Vec::Push */: ModuleGroup ModuleNamedBlockList;` /// @@ -32175,7 +32601,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 849: + /// Semantic action for production 859: /// /// `ModuleNamedBlockList /* Vec::New */: ;` /// @@ -32191,7 +32617,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 850: + /// Semantic action for production 860: /// /// `ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace;` /// @@ -32235,7 +32661,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 851: + /// Semantic action for production 861: /// /// `ModuleOptionalNamedBlockList /* Vec::Push */: ModuleGroup ModuleOptionalNamedBlockList;` /// @@ -32266,7 +32692,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 852: + /// Semantic action for production 862: /// /// `ModuleOptionalNamedBlockList /* Vec::New */: ;` /// @@ -32282,7 +32708,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 853: + /// Semantic action for production 863: /// /// `ModuleOptionalNamedBlockOpt /* Option::Some */: Colon Identifier;` /// @@ -32307,7 +32733,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 854: + /// Semantic action for production 864: /// /// `ModuleOptionalNamedBlockOpt /* Option::None */: ;` /// @@ -32319,7 +32745,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 855: + /// Semantic action for production 865: /// /// `ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup;` /// @@ -32344,7 +32770,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 856: + /// Semantic action for production 866: /// /// `ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace;` /// @@ -32375,7 +32801,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 857: + /// Semantic action for production 867: /// /// `ModuleGroupGroupList /* Vec::Push */: ModuleGroup ModuleGroupGroupList;` /// @@ -32402,7 +32828,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 858: + /// Semantic action for production 868: /// /// `ModuleGroupGroupList /* Vec::New */: ;` /// @@ -32418,7 +32844,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 859: + /// Semantic action for production 869: /// /// `ModuleGroupGroup: ModuleItem;` /// @@ -32438,7 +32864,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 860: + /// Semantic action for production 870: /// /// `ModuleGroupList /* Vec::Push */: Attribute ModuleGroupList;` /// @@ -32461,7 +32887,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 861: + /// Semantic action for production 871: /// /// `ModuleGroupList /* Vec::New */: ;` /// @@ -32474,7 +32900,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 862: + /// Semantic action for production 872: /// /// `ModuleItem: LetDeclaration;` /// @@ -32493,7 +32919,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 863: + /// Semantic action for production 873: /// /// `ModuleItem: VarDeclaration;` /// @@ -32512,7 +32938,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 864: + /// Semantic action for production 874: /// /// `ModuleItem: InstDeclaration;` /// @@ -32531,7 +32957,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 865: + /// Semantic action for production 875: /// /// `ModuleItem: TypeDefDeclaration;` /// @@ -32551,7 +32977,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 866: + /// Semantic action for production 876: /// /// `ModuleItem: LocalDeclaration;` /// @@ -32570,7 +32996,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 867: + /// Semantic action for production 877: /// /// `ModuleItem: AlwaysFfDeclaration;` /// @@ -32590,7 +33016,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 868: + /// Semantic action for production 878: /// /// `ModuleItem: AlwaysCombDeclaration;` /// @@ -32614,7 +33040,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 869: + /// Semantic action for production 879: /// /// `ModuleItem: AssignDeclaration;` /// @@ -32633,7 +33059,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 870: + /// Semantic action for production 880: /// /// `ModuleItem: FunctionDeclaration;` /// @@ -32653,7 +33079,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 871: + /// Semantic action for production 881: /// /// `ModuleItem: ModuleIfDeclaration;` /// @@ -32673,7 +33099,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 872: + /// Semantic action for production 882: /// /// `ModuleItem: ModuleForDeclaration;` /// @@ -32693,7 +33119,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 873: + /// Semantic action for production 883: /// /// `ModuleItem: EnumDeclaration;` /// @@ -32712,7 +33138,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 874: + /// Semantic action for production 884: /// /// `ModuleItem: StructUnionDeclaration;` /// @@ -32736,7 +33162,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 875: + /// Semantic action for production 885: /// /// `ModuleItem: ModuleNamedBlock;` /// @@ -32755,7 +33181,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 876: + /// Semantic action for production 886: /// /// `ModuleItem: ImportDeclaration;` /// @@ -32774,7 +33200,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 877: + /// Semantic action for production 887: /// /// `ModuleItem: InitialDeclaration;` /// @@ -32793,7 +33219,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 878: + /// Semantic action for production 888: /// /// `ModuleItem: FinalDeclaration;` /// @@ -32812,7 +33238,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 879: + /// Semantic action for production 889: /// /// `ModuleItem: UnsafeBlock;` /// @@ -32831,7 +33257,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 880: + /// Semantic action for production 890: /// /// `InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace;` /// @@ -32897,7 +33323,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 881: + /// Semantic action for production 891: /// /// `InterfaceDeclarationList /* Vec::Push */: InterfaceGroup InterfaceDeclarationList;` /// @@ -32928,7 +33354,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 882: + /// Semantic action for production 892: /// /// `InterfaceDeclarationList /* Vec::New */: ;` /// @@ -32944,7 +33370,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 883: + /// Semantic action for production 893: /// /// `InterfaceDeclarationOpt1 /* Option::Some */: WithParameter;` /// @@ -32963,7 +33389,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 884: + /// Semantic action for production 894: /// /// `InterfaceDeclarationOpt1 /* Option::None */: ;` /// @@ -32975,7 +33401,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 885: + /// Semantic action for production 895: /// /// `InterfaceDeclarationOpt0 /* Option::Some */: WithGenericParameter;` /// @@ -32998,7 +33424,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 886: + /// Semantic action for production 896: /// /// `InterfaceDeclarationOpt0 /* Option::None */: ;` /// @@ -33010,7 +33436,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 887: + /// Semantic action for production 897: /// /// `InterfaceDeclarationOpt /* Option::Some */: Pub;` /// @@ -33029,7 +33455,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 888: + /// Semantic action for production 898: /// /// `InterfaceDeclarationOpt /* Option::None */: ;` /// @@ -33041,7 +33467,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 889: + /// Semantic action for production 899: /// /// `InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */;` /// @@ -33089,7 +33515,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 890: + /// Semantic action for production 900: /// /// `InterfaceIfDeclarationList /* Vec::Push */: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList;` /// @@ -33134,7 +33560,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 891: + /// Semantic action for production 901: /// /// `InterfaceIfDeclarationList /* Vec::New */: ;` /// @@ -33150,7 +33576,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 892: + /// Semantic action for production 902: /// /// `InterfaceIfDeclarationOpt /* Option::Some */: Else InterfaceOptionalNamedBlock;` /// @@ -33180,7 +33606,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 893: + /// Semantic action for production 903: /// /// `InterfaceIfDeclarationOpt /* Option::None */: ;` /// @@ -33192,7 +33618,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 894: + /// Semantic action for production 904: /// /// `InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock;` /// @@ -33238,7 +33664,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 895: + /// Semantic action for production 905: /// /// `InterfaceForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression;` /// @@ -33266,7 +33692,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 896: + /// Semantic action for production 906: /// /// `InterfaceForDeclarationOpt /* Option::None */: ;` /// @@ -33278,7 +33704,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 897: + /// Semantic action for production 907: /// /// `InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace;` /// @@ -33320,7 +33746,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 898: + /// Semantic action for production 908: /// /// `InterfaceNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceNamedBlockList;` /// @@ -33351,7 +33777,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 899: + /// Semantic action for production 909: /// /// `InterfaceNamedBlockList /* Vec::New */: ;` /// @@ -33367,7 +33793,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 900: + /// Semantic action for production 910: /// /// `InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace;` /// @@ -33411,7 +33837,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 901: + /// Semantic action for production 911: /// /// `InterfaceOptionalNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceOptionalNamedBlockList;` /// @@ -33442,7 +33868,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 902: + /// Semantic action for production 912: /// /// `InterfaceOptionalNamedBlockList /* Vec::New */: ;` /// @@ -33458,7 +33884,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 903: + /// Semantic action for production 913: /// /// `InterfaceOptionalNamedBlockOpt /* Option::Some */: Colon Identifier;` /// @@ -33485,7 +33911,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 904: + /// Semantic action for production 914: /// /// `InterfaceOptionalNamedBlockOpt /* Option::None */: ;` /// @@ -33497,7 +33923,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 905: + /// Semantic action for production 915: /// /// `InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup;` /// @@ -33523,7 +33949,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 906: + /// Semantic action for production 916: /// /// `InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace;` /// @@ -33559,7 +33985,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 907: + /// Semantic action for production 917: /// /// `InterfaceGroupGroupList /* Vec::Push */: InterfaceGroup InterfaceGroupGroupList;` /// @@ -33590,7 +34016,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 908: + /// Semantic action for production 918: /// /// `InterfaceGroupGroupList /* Vec::New */: ;` /// @@ -33606,7 +34032,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 909: + /// Semantic action for production 919: /// /// `InterfaceGroupGroup: InterfaceItem;` /// @@ -33627,7 +34053,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 910: + /// Semantic action for production 920: /// /// `InterfaceGroupList /* Vec::Push */: Attribute InterfaceGroupList;` /// @@ -33651,7 +34077,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 911: + /// Semantic action for production 921: /// /// `InterfaceGroupList /* Vec::New */: ;` /// @@ -33667,7 +34093,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 912: + /// Semantic action for production 922: /// /// `InterfaceItem: LetDeclaration;` /// @@ -33686,7 +34112,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 913: + /// Semantic action for production 923: /// /// `InterfaceItem: VarDeclaration;` /// @@ -33705,7 +34131,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 914: + /// Semantic action for production 924: /// /// `InterfaceItem: LocalDeclaration;` /// @@ -33724,7 +34150,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 915: + /// Semantic action for production 925: /// /// `InterfaceItem: ModportDeclaration;` /// @@ -33743,7 +34169,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 916: + /// Semantic action for production 926: /// /// `InterfaceItem: InterfaceIfDeclaration;` /// @@ -33767,7 +34193,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 917: + /// Semantic action for production 927: /// /// `InterfaceItem: InterfaceForDeclaration;` /// @@ -33791,7 +34217,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 918: + /// Semantic action for production 928: /// /// `InterfaceItem: TypeDefDeclaration;` /// @@ -33811,7 +34237,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 919: + /// Semantic action for production 929: /// /// `InterfaceItem: EnumDeclaration;` /// @@ -33830,7 +34256,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 920: + /// Semantic action for production 930: /// /// `InterfaceItem: StructUnionDeclaration;` /// @@ -33854,7 +34280,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 921: + /// Semantic action for production 931: /// /// `InterfaceItem: InterfaceNamedBlock;` /// @@ -33874,7 +34300,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 922: + /// Semantic action for production 932: /// /// `InterfaceItem: FunctionDeclaration;` /// @@ -33894,7 +34320,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 923: + /// Semantic action for production 933: /// /// `InterfaceItem: ImportDeclaration;` /// @@ -33913,7 +34339,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 924: + /// Semantic action for production 934: /// /// `InterfaceItem: InitialDeclaration;` /// @@ -33932,7 +34358,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 925: + /// Semantic action for production 935: /// /// `InterfaceItem: FinalDeclaration;` /// @@ -33951,7 +34377,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 926: + /// Semantic action for production 936: /// /// `PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace;` /// @@ -34009,7 +34435,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 927: + /// Semantic action for production 937: /// /// `PackageDeclarationList /* Vec::Push */: PackageGroup PackageDeclarationList;` /// @@ -34040,7 +34466,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 928: + /// Semantic action for production 938: /// /// `PackageDeclarationList /* Vec::New */: ;` /// @@ -34056,7 +34482,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 929: + /// Semantic action for production 939: /// /// `PackageDeclarationOpt0 /* Option::Some */: WithGenericParameter;` /// @@ -34079,7 +34505,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 930: + /// Semantic action for production 940: /// /// `PackageDeclarationOpt0 /* Option::None */: ;` /// @@ -34091,7 +34517,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 931: + /// Semantic action for production 941: /// /// `PackageDeclarationOpt /* Option::Some */: Pub;` /// @@ -34110,7 +34536,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 932: + /// Semantic action for production 942: /// /// `PackageDeclarationOpt /* Option::None */: ;` /// @@ -34122,7 +34548,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 933: + /// Semantic action for production 943: /// /// `PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup;` /// @@ -34147,7 +34573,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 934: + /// Semantic action for production 944: /// /// `PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace;` /// @@ -34182,7 +34608,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 935: + /// Semantic action for production 945: /// /// `PackageGroupGroupList /* Vec::Push */: PackageGroup PackageGroupGroupList;` /// @@ -34213,7 +34639,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 936: + /// Semantic action for production 946: /// /// `PackageGroupGroupList /* Vec::New */: ;` /// @@ -34229,7 +34655,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 937: + /// Semantic action for production 947: /// /// `PackageGroupGroup: PackageItem;` /// @@ -34250,7 +34676,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 938: + /// Semantic action for production 948: /// /// `PackageGroupList /* Vec::Push */: Attribute PackageGroupList;` /// @@ -34273,7 +34699,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 939: + /// Semantic action for production 949: /// /// `PackageGroupList /* Vec::New */: ;` /// @@ -34289,7 +34715,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 940: + /// Semantic action for production 950: /// /// `PackageItem: VarDeclaration;` /// @@ -34308,7 +34734,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 941: + /// Semantic action for production 951: /// /// `PackageItem: LocalDeclaration;` /// @@ -34327,7 +34753,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 942: + /// Semantic action for production 952: /// /// `PackageItem: TypeDefDeclaration;` /// @@ -34347,7 +34773,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 943: + /// Semantic action for production 953: /// /// `PackageItem: EnumDeclaration;` /// @@ -34366,7 +34792,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 944: + /// Semantic action for production 954: /// /// `PackageItem: StructUnionDeclaration;` /// @@ -34390,7 +34816,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 945: + /// Semantic action for production 955: /// /// `PackageItem: FunctionDeclaration;` /// @@ -34410,7 +34836,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 946: + /// Semantic action for production 956: /// /// `PackageItem: ImportDeclaration;` /// @@ -34429,7 +34855,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 947: + /// Semantic action for production 957: /// /// `PackageItem: ExportDeclaration;` /// @@ -34448,7 +34874,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 948: + /// Semantic action for production 958: /// /// `PackageItem: InitialDeclaration;` /// @@ -34467,7 +34893,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 949: + /// Semantic action for production 959: /// /// `PackageItem: FinalDeclaration;` /// @@ -34486,7 +34912,164 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 950: + /// Semantic action for production 960: + /// + /// `ProtoModuleDeclaration: ProtoModuleDeclarationOpt /* Option */ Proto Module Identifier ProtoModuleDeclarationOpt0 /* Option */ ProtoModuleDeclarationOpt1 /* Option */ Semicolon;` + /// + #[parol_runtime::function_name::named] + fn proto_module_declaration( + &mut self, + _proto_module_declaration_opt: &ParseTreeType<'t>, + _proto: &ParseTreeType<'t>, + _module: &ParseTreeType<'t>, + _identifier: &ParseTreeType<'t>, + _proto_module_declaration_opt0: &ParseTreeType<'t>, + _proto_module_declaration_opt1: &ParseTreeType<'t>, + _semicolon: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let semicolon = pop_item!(self, semicolon, Semicolon, context); + let proto_module_declaration_opt1 = pop_item!( + self, + proto_module_declaration_opt1, + ProtoModuleDeclarationOpt1, + context + ); + let proto_module_declaration_opt0 = pop_item!( + self, + proto_module_declaration_opt0, + ProtoModuleDeclarationOpt0, + context + ); + let identifier = pop_item!(self, identifier, Identifier, context); + let module = pop_item!(self, module, Module, context); + let proto = pop_item!(self, proto, Proto, context); + let proto_module_declaration_opt = pop_item!( + self, + proto_module_declaration_opt, + ProtoModuleDeclarationOpt, + context + ); + let proto_module_declaration_built = ProtoModuleDeclaration { + proto_module_declaration_opt, + proto: Box::new(proto), + module: Box::new(module), + identifier: Box::new(identifier), + proto_module_declaration_opt0, + proto_module_declaration_opt1, + semicolon: Box::new(semicolon), + }; + // Calling user action here + self.user_grammar + .proto_module_declaration(&proto_module_declaration_built)?; + self.push( + ASTType::ProtoModuleDeclaration(proto_module_declaration_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 961: + /// + /// `ProtoModuleDeclarationOpt1 /* Option::Some */: PortDeclaration;` + /// + #[parol_runtime::function_name::named] + fn proto_module_declaration_opt1_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 proto_module_declaration_opt1_0_built = ProtoModuleDeclarationOpt1 { + port_declaration: Box::new(port_declaration), + }; + self.push( + ASTType::ProtoModuleDeclarationOpt1(Some(proto_module_declaration_opt1_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 962: + /// + /// `ProtoModuleDeclarationOpt1 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn proto_module_declaration_opt1_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ProtoModuleDeclarationOpt1(None), context); + Ok(()) + } + + /// Semantic action for production 963: + /// + /// `ProtoModuleDeclarationOpt0 /* Option::Some */: WithParameter;` + /// + #[parol_runtime::function_name::named] + fn proto_module_declaration_opt0_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 proto_module_declaration_opt0_0_built = ProtoModuleDeclarationOpt0 { + with_parameter: Box::new(with_parameter), + }; + self.push( + ASTType::ProtoModuleDeclarationOpt0(Some(proto_module_declaration_opt0_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 964: + /// + /// `ProtoModuleDeclarationOpt0 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn proto_module_declaration_opt0_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ProtoModuleDeclarationOpt0(None), context); + Ok(()) + } + + /// Semantic action for production 965: + /// + /// `ProtoModuleDeclarationOpt /* Option::Some */: Pub;` + /// + #[parol_runtime::function_name::named] + fn proto_module_declaration_opt_0(&mut self, _pub: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let r#pub = pop_item!(self, r#pub, Pub, context); + let proto_module_declaration_opt_0_built = ProtoModuleDeclarationOpt { + r#pub: Box::new(r#pub), + }; + self.push( + ASTType::ProtoModuleDeclarationOpt(Some(proto_module_declaration_opt_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 966: + /// + /// `ProtoModuleDeclarationOpt /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn proto_module_declaration_opt_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ProtoModuleDeclarationOpt(None), context); + Ok(()) + } + + /// Semantic action for production 967: /// /// `EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent;` /// @@ -34523,7 +35106,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 951: + /// Semantic action for production 968: /// /// `EmbedContent: EmbedContentToken : VerylToken;` /// @@ -34543,7 +35126,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 952: + /// Semantic action for production 969: /// /// `EmbedContentToken: LBraceTerm %push(Embed) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm %pop() Comments;` /// @@ -34594,7 +35177,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 953: + /// Semantic action for production 970: /// /// `EmbedContentTokenList /* Vec::Push */: EmbedItem EmbedContentTokenList;` /// @@ -34625,7 +35208,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 954: + /// Semantic action for production 971: /// /// `EmbedContentTokenList /* Vec::New */: ;` /// @@ -34641,7 +35224,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 955: + /// Semantic action for production 972: /// /// `EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm;` /// @@ -34669,7 +35252,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 956: + /// Semantic action for production 973: /// /// `EmbedItemList /* Vec::Push */: EmbedItem EmbedItemList;` /// @@ -34692,7 +35275,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 957: + /// Semantic action for production 974: /// /// `EmbedItemList /* Vec::New */: ;` /// @@ -34705,7 +35288,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 958: + /// Semantic action for production 975: /// /// `EmbedItem: AnyTerm;` /// @@ -34724,7 +35307,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 959: + /// Semantic action for production 976: /// /// `IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon;` /// @@ -34767,7 +35350,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 960: + /// Semantic action for production 977: /// /// `DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup;` /// @@ -34798,7 +35381,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 961: + /// Semantic action for production 978: /// /// `DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace;` /// @@ -34836,7 +35419,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 962: + /// Semantic action for production 979: /// /// `DescriptionGroupGroupList /* Vec::Push */: DescriptionGroup DescriptionGroupGroupList;` /// @@ -34867,7 +35450,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 963: + /// Semantic action for production 980: /// /// `DescriptionGroupGroupList /* Vec::New */: ;` /// @@ -34883,7 +35466,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 964: + /// Semantic action for production 981: /// /// `DescriptionGroupGroup: DescriptionItem;` /// @@ -34904,7 +35487,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 965: + /// Semantic action for production 982: /// /// `DescriptionGroupList /* Vec::Push */: Attribute DescriptionGroupList;` /// @@ -34931,7 +35514,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 966: + /// Semantic action for production 983: /// /// `DescriptionGroupList /* Vec::New */: ;` /// @@ -34947,7 +35530,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 967: + /// Semantic action for production 984: /// /// `DescriptionItem: ModuleDeclaration;` /// @@ -34967,7 +35550,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 968: + /// Semantic action for production 985: /// /// `DescriptionItem: InterfaceDeclaration;` /// @@ -34989,7 +35572,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 969: + /// Semantic action for production 986: /// /// `DescriptionItem: PackageDeclaration;` /// @@ -35010,68 +35593,94 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 970: + /// Semantic action for production 987: + /// + /// `DescriptionItem: ProtoModuleDeclaration;` + /// + #[parol_runtime::function_name::named] + fn description_item_3(&mut self, _proto_module_declaration: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let proto_module_declaration = pop_item!( + self, + proto_module_declaration, + ProtoModuleDeclaration, + context + ); + let description_item_3_built = DescriptionItemProtoModuleDeclaration { + proto_module_declaration: Box::new(proto_module_declaration), + }; + let description_item_3_built = + DescriptionItem::ProtoModuleDeclaration(description_item_3_built); + // Calling user action here + self.user_grammar + .description_item(&description_item_3_built)?; + self.push(ASTType::DescriptionItem(description_item_3_built), context); + Ok(()) + } + + /// Semantic action for production 988: /// /// `DescriptionItem: ImportDeclaration;` /// #[parol_runtime::function_name::named] - fn description_item_3(&mut self, _import_declaration: &ParseTreeType<'t>) -> Result<()> { + fn description_item_4(&mut self, _import_declaration: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let import_declaration = pop_item!(self, import_declaration, ImportDeclaration, context); - let description_item_3_built = DescriptionItemImportDeclaration { + let description_item_4_built = DescriptionItemImportDeclaration { import_declaration: Box::new(import_declaration), }; - let description_item_3_built = DescriptionItem::ImportDeclaration(description_item_3_built); + let description_item_4_built = DescriptionItem::ImportDeclaration(description_item_4_built); // Calling user action here self.user_grammar - .description_item(&description_item_3_built)?; - self.push(ASTType::DescriptionItem(description_item_3_built), context); + .description_item(&description_item_4_built)?; + self.push(ASTType::DescriptionItem(description_item_4_built), context); Ok(()) } - /// Semantic action for production 971: + /// Semantic action for production 989: /// /// `DescriptionItem: EmbedDeclaration;` /// #[parol_runtime::function_name::named] - fn description_item_4(&mut self, _embed_declaration: &ParseTreeType<'t>) -> Result<()> { + fn description_item_5(&mut self, _embed_declaration: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let embed_declaration = pop_item!(self, embed_declaration, EmbedDeclaration, context); - let description_item_4_built = DescriptionItemEmbedDeclaration { + let description_item_5_built = DescriptionItemEmbedDeclaration { embed_declaration: Box::new(embed_declaration), }; - let description_item_4_built = DescriptionItem::EmbedDeclaration(description_item_4_built); + let description_item_5_built = DescriptionItem::EmbedDeclaration(description_item_5_built); // Calling user action here self.user_grammar - .description_item(&description_item_4_built)?; - self.push(ASTType::DescriptionItem(description_item_4_built), context); + .description_item(&description_item_5_built)?; + self.push(ASTType::DescriptionItem(description_item_5_built), context); Ok(()) } - /// Semantic action for production 972: + /// Semantic action for production 990: /// /// `DescriptionItem: IncludeDeclaration;` /// #[parol_runtime::function_name::named] - fn description_item_5(&mut self, _include_declaration: &ParseTreeType<'t>) -> Result<()> { + fn description_item_6(&mut self, _include_declaration: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let include_declaration = pop_item!(self, include_declaration, IncludeDeclaration, context); - let description_item_5_built = DescriptionItemIncludeDeclaration { + let description_item_6_built = DescriptionItemIncludeDeclaration { include_declaration: Box::new(include_declaration), }; - let description_item_5_built = - DescriptionItem::IncludeDeclaration(description_item_5_built); + let description_item_6_built = + DescriptionItem::IncludeDeclaration(description_item_6_built); // Calling user action here self.user_grammar - .description_item(&description_item_5_built)?; - self.push(ASTType::DescriptionItem(description_item_5_built), context); + .description_item(&description_item_6_built)?; + self.push(ASTType::DescriptionItem(description_item_6_built), context); Ok(()) } - /// Semantic action for production 973: + /// Semantic action for production 991: /// /// `Veryl: Start VerylList /* Vec */;` /// @@ -35091,7 +35700,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 974: + /// Semantic action for production 992: /// /// `VerylList /* Vec::Push */: DescriptionGroup VerylList;` /// @@ -35114,7 +35723,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 975: + /// Semantic action for production 993: /// /// `VerylList /* Vec::New */: ;` /// @@ -35191,425 +35800,431 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { 50 => self.clock_term(&children[0]), 51 => self.clock_posedge_term(&children[0]), 52 => self.clock_negedge_term(&children[0]), - 53 => self.default_term(&children[0]), - 54 => self.else_term(&children[0]), - 55 => self.embed_term(&children[0]), - 56 => self.enum_term(&children[0]), - 57 => self.export_term(&children[0]), - 58 => self.f32_term(&children[0]), - 59 => self.f64_term(&children[0]), - 60 => self.final_term(&children[0]), - 61 => self.for_term(&children[0]), - 62 => self.function_term(&children[0]), - 63 => self.i32_term(&children[0]), - 64 => self.i64_term(&children[0]), - 65 => self.if_reset_term(&children[0]), - 66 => self.if_term(&children[0]), - 67 => self.import_term(&children[0]), - 68 => self.include_term(&children[0]), - 69 => self.initial_term(&children[0]), - 70 => self.inout_term(&children[0]), - 71 => self.input_term(&children[0]), - 72 => self.inside_term(&children[0]), - 73 => self.inst_term(&children[0]), - 74 => self.interface_term(&children[0]), - 75 => self.in_term(&children[0]), - 76 => self.let_term(&children[0]), - 77 => self.local_term(&children[0]), - 78 => self.logic_term(&children[0]), - 79 => self.lsb_term(&children[0]), - 80 => self.modport_term(&children[0]), - 81 => self.module_term(&children[0]), - 82 => self.msb_term(&children[0]), - 83 => self.output_term(&children[0]), - 84 => self.outside_term(&children[0]), - 85 => self.package_term(&children[0]), - 86 => self.param_term(&children[0]), - 87 => self.pub_term(&children[0]), - 88 => self.ref_term(&children[0]), - 89 => self.repeat_term(&children[0]), - 90 => self.reset_term(&children[0]), - 91 => self.reset_async_high_term(&children[0]), - 92 => self.reset_async_low_term(&children[0]), - 93 => self.reset_sync_high_term(&children[0]), - 94 => self.reset_sync_low_term(&children[0]), - 95 => self.return_term(&children[0]), - 96 => self.break_term(&children[0]), - 97 => self.signed_term(&children[0]), - 98 => self.step_term(&children[0]), - 99 => self.string_term(&children[0]), - 100 => self.struct_term(&children[0]), - 101 => self.switch_term(&children[0]), - 102 => self.tri_term(&children[0]), - 103 => self.type_term(&children[0]), - 104 => self.u32_term(&children[0]), - 105 => self.u64_term(&children[0]), - 106 => self.union_term(&children[0]), - 107 => self.unsafe_term(&children[0]), - 108 => self.var_term(&children[0]), - 109 => self.dollar_identifier_term(&children[0]), - 110 => self.identifier_term(&children[0]), - 111 => self.any_term(&children[0]), - 112 => self.comments(&children[0]), - 113 => self.comments_opt_0(&children[0]), - 114 => self.comments_opt_1(), - 115 => self.start_token(&children[0]), - 116 => self.string_literal_token(&children[0], &children[1]), - 117 => self.exponent_token(&children[0], &children[1]), - 118 => self.fixed_point_token(&children[0], &children[1]), - 119 => self.based_token(&children[0], &children[1]), - 120 => self.base_less_token(&children[0], &children[1]), - 121 => self.all_bit_token(&children[0], &children[1]), - 122 => self.assignment_operator_token(&children[0], &children[1]), - 123 => self.operator01_token(&children[0], &children[1]), - 124 => self.operator02_token(&children[0], &children[1]), - 125 => self.operator03_token(&children[0], &children[1]), - 126 => self.operator04_token(&children[0], &children[1]), - 127 => self.operator05_token(&children[0], &children[1]), - 128 => self.operator06_token(&children[0], &children[1]), - 129 => self.operator07_token(&children[0], &children[1]), - 130 => self.operator08_token(&children[0], &children[1]), - 131 => self.operator09_token(&children[0], &children[1]), - 132 => self.operator10_token(&children[0], &children[1]), - 133 => self.operator11_token(&children[0], &children[1]), - 134 => self.unary_operator_token(&children[0], &children[1]), - 135 => self.back_quote_token(&children[0], &children[1]), - 136 => self.colon_token(&children[0], &children[1]), - 137 => self.colon_colon_l_angle_token(&children[0], &children[1]), - 138 => self.colon_colon_token(&children[0], &children[1]), - 139 => self.comma_token(&children[0], &children[1]), - 140 => self.dot_dot_token(&children[0], &children[1]), - 141 => self.dot_dot_equ_token(&children[0], &children[1]), - 142 => self.dot_token(&children[0], &children[1]), - 143 => self.equ_token(&children[0], &children[1]), - 144 => self.hash_token(&children[0], &children[1]), - 145 => self.quote_l_brace_token(&children[0], &children[1]), - 146 => self.l_angle_token(&children[0], &children[1]), - 147 => self.l_brace_token(&children[0], &children[1]), - 148 => self.l_bracket_token(&children[0], &children[1]), - 149 => self.l_paren_token(&children[0], &children[1]), - 150 => self.minus_colon_token(&children[0], &children[1]), - 151 => self.minus_g_t_token(&children[0], &children[1]), - 152 => self.plus_colon_token(&children[0], &children[1]), - 153 => self.r_angle_token(&children[0], &children[1]), - 154 => self.r_brace_token(&children[0], &children[1]), - 155 => self.r_bracket_token(&children[0], &children[1]), - 156 => self.r_paren_token(&children[0], &children[1]), - 157 => self.semicolon_token(&children[0], &children[1]), - 158 => self.star_token(&children[0], &children[1]), - 159 => self.always_comb_token(&children[0], &children[1]), - 160 => self.always_ff_token(&children[0], &children[1]), - 161 => self.as_token(&children[0], &children[1]), - 162 => self.assign_token(&children[0], &children[1]), - 163 => self.bit_token(&children[0], &children[1]), - 164 => self.case_token(&children[0], &children[1]), - 165 => self.clock_token(&children[0], &children[1]), - 166 => self.clock_posedge_token(&children[0], &children[1]), - 167 => self.clock_negedge_token(&children[0], &children[1]), - 168 => self.default_token(&children[0], &children[1]), - 169 => self.else_token(&children[0], &children[1]), - 170 => self.embed_token(&children[0], &children[1]), - 171 => self.enum_token(&children[0], &children[1]), - 172 => self.export_token(&children[0], &children[1]), - 173 => self.f32_token(&children[0], &children[1]), - 174 => self.f64_token(&children[0], &children[1]), - 175 => self.final_token(&children[0], &children[1]), - 176 => self.for_token(&children[0], &children[1]), - 177 => self.function_token(&children[0], &children[1]), - 178 => self.i32_token(&children[0], &children[1]), - 179 => self.i64_token(&children[0], &children[1]), - 180 => self.if_reset_token(&children[0], &children[1]), - 181 => self.if_token(&children[0], &children[1]), - 182 => self.import_token(&children[0], &children[1]), - 183 => self.include_token(&children[0], &children[1]), - 184 => self.initial_token(&children[0], &children[1]), - 185 => self.inout_token(&children[0], &children[1]), - 186 => self.input_token(&children[0], &children[1]), - 187 => self.inside_token(&children[0], &children[1]), - 188 => self.inst_token(&children[0], &children[1]), - 189 => self.interface_token(&children[0], &children[1]), - 190 => self.in_token(&children[0], &children[1]), - 191 => self.let_token(&children[0], &children[1]), - 192 => self.local_token(&children[0], &children[1]), - 193 => self.logic_token(&children[0], &children[1]), - 194 => self.lsb_token(&children[0], &children[1]), - 195 => self.modport_token(&children[0], &children[1]), - 196 => self.module_token(&children[0], &children[1]), - 197 => self.msb_token(&children[0], &children[1]), - 198 => self.output_token(&children[0], &children[1]), - 199 => self.outside_token(&children[0], &children[1]), - 200 => self.package_token(&children[0], &children[1]), - 201 => self.param_token(&children[0], &children[1]), - 202 => self.pub_token(&children[0], &children[1]), - 203 => self.ref_token(&children[0], &children[1]), - 204 => self.repeat_token(&children[0], &children[1]), - 205 => self.reset_token(&children[0], &children[1]), - 206 => self.reset_async_high_token(&children[0], &children[1]), - 207 => self.reset_async_low_token(&children[0], &children[1]), - 208 => self.reset_sync_high_token(&children[0], &children[1]), - 209 => self.reset_sync_low_token(&children[0], &children[1]), - 210 => self.return_token(&children[0], &children[1]), - 211 => self.break_token(&children[0], &children[1]), - 212 => self.signed_token(&children[0], &children[1]), - 213 => self.step_token(&children[0], &children[1]), - 214 => self.string_token(&children[0], &children[1]), - 215 => self.struct_token(&children[0], &children[1]), - 216 => self.switch_token(&children[0], &children[1]), - 217 => self.tri_token(&children[0], &children[1]), - 218 => self.type_token(&children[0], &children[1]), - 219 => self.u32_token(&children[0], &children[1]), - 220 => self.u64_token(&children[0], &children[1]), - 221 => self.union_token(&children[0], &children[1]), - 222 => self.unsafe_token(&children[0], &children[1]), - 223 => self.var_token(&children[0], &children[1]), - 224 => self.dollar_identifier_token(&children[0], &children[1]), - 225 => self.identifier_token(&children[0], &children[1]), - 226 => self.start(&children[0]), - 227 => self.string_literal(&children[0]), - 228 => self.exponent(&children[0]), - 229 => self.fixed_point(&children[0]), - 230 => self.based(&children[0]), - 231 => self.base_less(&children[0]), - 232 => self.all_bit(&children[0]), - 233 => self.assignment_operator(&children[0]), - 234 => self.operator01(&children[0]), - 235 => self.operator02(&children[0]), - 236 => self.operator03(&children[0]), - 237 => self.operator04(&children[0]), - 238 => self.operator05(&children[0]), - 239 => self.operator06(&children[0]), - 240 => self.operator07(&children[0]), - 241 => self.operator08(&children[0]), - 242 => self.operator09(&children[0]), - 243 => self.operator10(&children[0]), - 244 => self.operator11(&children[0]), - 245 => self.unary_operator(&children[0]), - 246 => self.back_quote(&children[0]), - 247 => self.colon(&children[0]), - 248 => self.colon_colon_l_angle(&children[0]), - 249 => self.colon_colon(&children[0]), - 250 => self.comma(&children[0]), - 251 => self.dot_dot(&children[0]), - 252 => self.dot_dot_equ(&children[0]), - 253 => self.dot(&children[0]), - 254 => self.equ(&children[0]), - 255 => self.hash(&children[0]), - 256 => self.quote_l_brace(&children[0]), - 257 => self.l_angle(&children[0]), - 258 => self.l_brace(&children[0]), - 259 => self.l_bracket(&children[0]), - 260 => self.l_paren(&children[0]), - 261 => self.minus_colon(&children[0]), - 262 => self.minus_g_t(&children[0]), - 263 => self.plus_colon(&children[0]), - 264 => self.r_angle(&children[0]), - 265 => self.r_brace(&children[0]), - 266 => self.r_bracket(&children[0]), - 267 => self.r_paren(&children[0]), - 268 => self.semicolon(&children[0]), - 269 => self.star(&children[0]), - 270 => self.always_comb(&children[0]), - 271 => self.always_ff(&children[0]), - 272 => self.r#as(&children[0]), - 273 => self.assign(&children[0]), - 274 => self.bit(&children[0]), - 275 => self.r#break(&children[0]), - 276 => self.case(&children[0]), - 277 => self.clock(&children[0]), - 278 => self.clock_posedge(&children[0]), - 279 => self.clock_negedge(&children[0]), - 280 => self.defaul(&children[0]), - 281 => self.r#else(&children[0]), - 282 => self.embed(&children[0]), - 283 => self.r#enum(&children[0]), - 284 => self.export(&children[0]), - 285 => self.f32(&children[0]), - 286 => self.f64(&children[0]), - 287 => self.r#final(&children[0]), - 288 => self.r#for(&children[0]), - 289 => self.function(&children[0]), - 290 => self.i32(&children[0]), - 291 => self.i64(&children[0]), - 292 => self.r#if(&children[0]), - 293 => self.if_reset(&children[0]), - 294 => self.import(&children[0]), - 295 => self.r#in(&children[0]), - 296 => self.include(&children[0]), - 297 => self.initial(&children[0]), - 298 => self.inout(&children[0]), - 299 => self.input(&children[0]), - 300 => self.inside(&children[0]), - 301 => self.inst(&children[0]), - 302 => self.interface(&children[0]), - 303 => self.r#let(&children[0]), - 304 => self.local(&children[0]), - 305 => self.logic(&children[0]), - 306 => self.lsb(&children[0]), - 307 => self.modport(&children[0]), - 308 => self.module(&children[0]), - 309 => self.msb(&children[0]), - 310 => self.output(&children[0]), - 311 => self.outside(&children[0]), - 312 => self.package(&children[0]), - 313 => self.param(&children[0]), - 314 => self.r#pub(&children[0]), - 315 => self.r#ref(&children[0]), - 316 => self.repeat(&children[0]), - 317 => self.reset(&children[0]), - 318 => self.reset_async_high(&children[0]), - 319 => self.reset_async_low(&children[0]), - 320 => self.reset_sync_high(&children[0]), - 321 => self.reset_sync_low(&children[0]), - 322 => self.r#return(&children[0]), - 323 => self.signed(&children[0]), - 324 => self.step(&children[0]), - 325 => self.strin(&children[0]), - 326 => self.r#struct(&children[0]), - 327 => self.switch(&children[0]), - 328 => self.tri(&children[0]), - 329 => self.r#type(&children[0]), - 330 => self.u32(&children[0]), - 331 => self.u64(&children[0]), - 332 => self.r#union(&children[0]), - 333 => self.r#unsafe(&children[0]), - 334 => self.var(&children[0]), - 335 => self.dollar_identifier(&children[0]), - 336 => self.identifier(&children[0]), - 337 => self.number_0(&children[0]), - 338 => self.number_1(&children[0]), - 339 => self.integral_number_0(&children[0]), - 340 => self.integral_number_1(&children[0]), - 341 => self.integral_number_2(&children[0]), - 342 => self.real_number_0(&children[0]), - 343 => self.real_number_1(&children[0]), - 344 => self.hierarchical_identifier(&children[0], &children[1], &children[2]), - 345 => self.hierarchical_identifier_list0_0( + 53 => self.const_term(&children[0]), + 54 => self.default_term(&children[0]), + 55 => self.else_term(&children[0]), + 56 => self.embed_term(&children[0]), + 57 => self.enum_term(&children[0]), + 58 => self.export_term(&children[0]), + 59 => self.f32_term(&children[0]), + 60 => self.f64_term(&children[0]), + 61 => self.final_term(&children[0]), + 62 => self.for_term(&children[0]), + 63 => self.function_term(&children[0]), + 64 => self.i32_term(&children[0]), + 65 => self.i64_term(&children[0]), + 66 => self.if_reset_term(&children[0]), + 67 => self.if_term(&children[0]), + 68 => self.import_term(&children[0]), + 69 => self.include_term(&children[0]), + 70 => self.initial_term(&children[0]), + 71 => self.inout_term(&children[0]), + 72 => self.input_term(&children[0]), + 73 => self.inside_term(&children[0]), + 74 => self.inst_term(&children[0]), + 75 => self.interface_term(&children[0]), + 76 => self.in_term(&children[0]), + 77 => self.let_term(&children[0]), + 78 => self.local_term(&children[0]), + 79 => self.logic_term(&children[0]), + 80 => self.lsb_term(&children[0]), + 81 => self.modport_term(&children[0]), + 82 => self.module_term(&children[0]), + 83 => self.msb_term(&children[0]), + 84 => self.output_term(&children[0]), + 85 => self.outside_term(&children[0]), + 86 => self.package_term(&children[0]), + 87 => self.param_term(&children[0]), + 88 => self.proto_term(&children[0]), + 89 => self.pub_term(&children[0]), + 90 => self.ref_term(&children[0]), + 91 => self.repeat_term(&children[0]), + 92 => self.reset_term(&children[0]), + 93 => self.reset_async_high_term(&children[0]), + 94 => self.reset_async_low_term(&children[0]), + 95 => self.reset_sync_high_term(&children[0]), + 96 => self.reset_sync_low_term(&children[0]), + 97 => self.return_term(&children[0]), + 98 => self.break_term(&children[0]), + 99 => self.signed_term(&children[0]), + 100 => self.step_term(&children[0]), + 101 => self.string_term(&children[0]), + 102 => self.struct_term(&children[0]), + 103 => self.switch_term(&children[0]), + 104 => self.tri_term(&children[0]), + 105 => self.type_term(&children[0]), + 106 => self.u32_term(&children[0]), + 107 => self.u64_term(&children[0]), + 108 => self.union_term(&children[0]), + 109 => self.unsafe_term(&children[0]), + 110 => self.var_term(&children[0]), + 111 => self.dollar_identifier_term(&children[0]), + 112 => self.identifier_term(&children[0]), + 113 => self.any_term(&children[0]), + 114 => self.comments(&children[0]), + 115 => self.comments_opt_0(&children[0]), + 116 => self.comments_opt_1(), + 117 => self.start_token(&children[0]), + 118 => self.string_literal_token(&children[0], &children[1]), + 119 => self.exponent_token(&children[0], &children[1]), + 120 => self.fixed_point_token(&children[0], &children[1]), + 121 => self.based_token(&children[0], &children[1]), + 122 => self.base_less_token(&children[0], &children[1]), + 123 => self.all_bit_token(&children[0], &children[1]), + 124 => self.assignment_operator_token(&children[0], &children[1]), + 125 => self.operator01_token(&children[0], &children[1]), + 126 => self.operator02_token(&children[0], &children[1]), + 127 => self.operator03_token(&children[0], &children[1]), + 128 => self.operator04_token(&children[0], &children[1]), + 129 => self.operator05_token(&children[0], &children[1]), + 130 => self.operator06_token(&children[0], &children[1]), + 131 => self.operator07_token(&children[0], &children[1]), + 132 => self.operator08_token(&children[0], &children[1]), + 133 => self.operator09_token(&children[0], &children[1]), + 134 => self.operator10_token(&children[0], &children[1]), + 135 => self.operator11_token(&children[0], &children[1]), + 136 => self.unary_operator_token(&children[0], &children[1]), + 137 => self.back_quote_token(&children[0], &children[1]), + 138 => self.colon_token(&children[0], &children[1]), + 139 => self.colon_colon_l_angle_token(&children[0], &children[1]), + 140 => self.colon_colon_token(&children[0], &children[1]), + 141 => self.comma_token(&children[0], &children[1]), + 142 => self.dot_dot_token(&children[0], &children[1]), + 143 => self.dot_dot_equ_token(&children[0], &children[1]), + 144 => self.dot_token(&children[0], &children[1]), + 145 => self.equ_token(&children[0], &children[1]), + 146 => self.hash_token(&children[0], &children[1]), + 147 => self.quote_l_brace_token(&children[0], &children[1]), + 148 => self.l_angle_token(&children[0], &children[1]), + 149 => self.l_brace_token(&children[0], &children[1]), + 150 => self.l_bracket_token(&children[0], &children[1]), + 151 => self.l_paren_token(&children[0], &children[1]), + 152 => self.minus_colon_token(&children[0], &children[1]), + 153 => self.minus_g_t_token(&children[0], &children[1]), + 154 => self.plus_colon_token(&children[0], &children[1]), + 155 => self.r_angle_token(&children[0], &children[1]), + 156 => self.r_brace_token(&children[0], &children[1]), + 157 => self.r_bracket_token(&children[0], &children[1]), + 158 => self.r_paren_token(&children[0], &children[1]), + 159 => self.semicolon_token(&children[0], &children[1]), + 160 => self.star_token(&children[0], &children[1]), + 161 => self.always_comb_token(&children[0], &children[1]), + 162 => self.always_ff_token(&children[0], &children[1]), + 163 => self.as_token(&children[0], &children[1]), + 164 => self.assign_token(&children[0], &children[1]), + 165 => self.bit_token(&children[0], &children[1]), + 166 => self.case_token(&children[0], &children[1]), + 167 => self.clock_token(&children[0], &children[1]), + 168 => self.clock_posedge_token(&children[0], &children[1]), + 169 => self.clock_negedge_token(&children[0], &children[1]), + 170 => self.const_token(&children[0], &children[1]), + 171 => self.default_token(&children[0], &children[1]), + 172 => self.else_token(&children[0], &children[1]), + 173 => self.embed_token(&children[0], &children[1]), + 174 => self.enum_token(&children[0], &children[1]), + 175 => self.export_token(&children[0], &children[1]), + 176 => self.f32_token(&children[0], &children[1]), + 177 => self.f64_token(&children[0], &children[1]), + 178 => self.final_token(&children[0], &children[1]), + 179 => self.for_token(&children[0], &children[1]), + 180 => self.function_token(&children[0], &children[1]), + 181 => self.i32_token(&children[0], &children[1]), + 182 => self.i64_token(&children[0], &children[1]), + 183 => self.if_reset_token(&children[0], &children[1]), + 184 => self.if_token(&children[0], &children[1]), + 185 => self.import_token(&children[0], &children[1]), + 186 => self.include_token(&children[0], &children[1]), + 187 => self.initial_token(&children[0], &children[1]), + 188 => self.inout_token(&children[0], &children[1]), + 189 => self.input_token(&children[0], &children[1]), + 190 => self.inside_token(&children[0], &children[1]), + 191 => self.inst_token(&children[0], &children[1]), + 192 => self.interface_token(&children[0], &children[1]), + 193 => self.in_token(&children[0], &children[1]), + 194 => self.let_token(&children[0], &children[1]), + 195 => self.local_token(&children[0], &children[1]), + 196 => self.logic_token(&children[0], &children[1]), + 197 => self.lsb_token(&children[0], &children[1]), + 198 => self.modport_token(&children[0], &children[1]), + 199 => self.module_token(&children[0], &children[1]), + 200 => self.msb_token(&children[0], &children[1]), + 201 => self.output_token(&children[0], &children[1]), + 202 => self.outside_token(&children[0], &children[1]), + 203 => self.package_token(&children[0], &children[1]), + 204 => self.param_token(&children[0], &children[1]), + 205 => self.proto_token(&children[0], &children[1]), + 206 => self.pub_token(&children[0], &children[1]), + 207 => self.ref_token(&children[0], &children[1]), + 208 => self.repeat_token(&children[0], &children[1]), + 209 => self.reset_token(&children[0], &children[1]), + 210 => self.reset_async_high_token(&children[0], &children[1]), + 211 => self.reset_async_low_token(&children[0], &children[1]), + 212 => self.reset_sync_high_token(&children[0], &children[1]), + 213 => self.reset_sync_low_token(&children[0], &children[1]), + 214 => self.return_token(&children[0], &children[1]), + 215 => self.break_token(&children[0], &children[1]), + 216 => self.signed_token(&children[0], &children[1]), + 217 => self.step_token(&children[0], &children[1]), + 218 => self.string_token(&children[0], &children[1]), + 219 => self.struct_token(&children[0], &children[1]), + 220 => self.switch_token(&children[0], &children[1]), + 221 => self.tri_token(&children[0], &children[1]), + 222 => self.type_token(&children[0], &children[1]), + 223 => self.u32_token(&children[0], &children[1]), + 224 => self.u64_token(&children[0], &children[1]), + 225 => self.union_token(&children[0], &children[1]), + 226 => self.unsafe_token(&children[0], &children[1]), + 227 => self.var_token(&children[0], &children[1]), + 228 => self.dollar_identifier_token(&children[0], &children[1]), + 229 => self.identifier_token(&children[0], &children[1]), + 230 => self.start(&children[0]), + 231 => self.string_literal(&children[0]), + 232 => self.exponent(&children[0]), + 233 => self.fixed_point(&children[0]), + 234 => self.based(&children[0]), + 235 => self.base_less(&children[0]), + 236 => self.all_bit(&children[0]), + 237 => self.assignment_operator(&children[0]), + 238 => self.operator01(&children[0]), + 239 => self.operator02(&children[0]), + 240 => self.operator03(&children[0]), + 241 => self.operator04(&children[0]), + 242 => self.operator05(&children[0]), + 243 => self.operator06(&children[0]), + 244 => self.operator07(&children[0]), + 245 => self.operator08(&children[0]), + 246 => self.operator09(&children[0]), + 247 => self.operator10(&children[0]), + 248 => self.operator11(&children[0]), + 249 => self.unary_operator(&children[0]), + 250 => self.back_quote(&children[0]), + 251 => self.colon(&children[0]), + 252 => self.colon_colon_l_angle(&children[0]), + 253 => self.colon_colon(&children[0]), + 254 => self.comma(&children[0]), + 255 => self.dot_dot(&children[0]), + 256 => self.dot_dot_equ(&children[0]), + 257 => self.dot(&children[0]), + 258 => self.equ(&children[0]), + 259 => self.hash(&children[0]), + 260 => self.quote_l_brace(&children[0]), + 261 => self.l_angle(&children[0]), + 262 => self.l_brace(&children[0]), + 263 => self.l_bracket(&children[0]), + 264 => self.l_paren(&children[0]), + 265 => self.minus_colon(&children[0]), + 266 => self.minus_g_t(&children[0]), + 267 => self.plus_colon(&children[0]), + 268 => self.r_angle(&children[0]), + 269 => self.r_brace(&children[0]), + 270 => self.r_bracket(&children[0]), + 271 => self.r_paren(&children[0]), + 272 => self.semicolon(&children[0]), + 273 => self.star(&children[0]), + 274 => self.always_comb(&children[0]), + 275 => self.always_ff(&children[0]), + 276 => self.r#as(&children[0]), + 277 => self.assign(&children[0]), + 278 => self.bit(&children[0]), + 279 => self.r#break(&children[0]), + 280 => self.case(&children[0]), + 281 => self.clock(&children[0]), + 282 => self.clock_posedge(&children[0]), + 283 => self.clock_negedge(&children[0]), + 284 => self.r#const(&children[0]), + 285 => self.defaul(&children[0]), + 286 => self.r#else(&children[0]), + 287 => self.embed(&children[0]), + 288 => self.r#enum(&children[0]), + 289 => self.export(&children[0]), + 290 => self.f32(&children[0]), + 291 => self.f64(&children[0]), + 292 => self.r#final(&children[0]), + 293 => self.r#for(&children[0]), + 294 => self.function(&children[0]), + 295 => self.i32(&children[0]), + 296 => self.i64(&children[0]), + 297 => self.r#if(&children[0]), + 298 => self.if_reset(&children[0]), + 299 => self.import(&children[0]), + 300 => self.r#in(&children[0]), + 301 => self.include(&children[0]), + 302 => self.initial(&children[0]), + 303 => self.inout(&children[0]), + 304 => self.input(&children[0]), + 305 => self.inside(&children[0]), + 306 => self.inst(&children[0]), + 307 => self.interface(&children[0]), + 308 => self.r#let(&children[0]), + 309 => self.local(&children[0]), + 310 => self.logic(&children[0]), + 311 => self.lsb(&children[0]), + 312 => self.modport(&children[0]), + 313 => self.module(&children[0]), + 314 => self.msb(&children[0]), + 315 => self.output(&children[0]), + 316 => self.outside(&children[0]), + 317 => self.package(&children[0]), + 318 => self.param(&children[0]), + 319 => self.proto(&children[0]), + 320 => self.r#pub(&children[0]), + 321 => self.r#ref(&children[0]), + 322 => self.repeat(&children[0]), + 323 => self.reset(&children[0]), + 324 => self.reset_async_high(&children[0]), + 325 => self.reset_async_low(&children[0]), + 326 => self.reset_sync_high(&children[0]), + 327 => self.reset_sync_low(&children[0]), + 328 => self.r#return(&children[0]), + 329 => self.signed(&children[0]), + 330 => self.step(&children[0]), + 331 => self.strin(&children[0]), + 332 => self.r#struct(&children[0]), + 333 => self.switch(&children[0]), + 334 => self.tri(&children[0]), + 335 => self.r#type(&children[0]), + 336 => self.u32(&children[0]), + 337 => self.u64(&children[0]), + 338 => self.r#union(&children[0]), + 339 => self.r#unsafe(&children[0]), + 340 => self.var(&children[0]), + 341 => self.dollar_identifier(&children[0]), + 342 => self.identifier(&children[0]), + 343 => self.number_0(&children[0]), + 344 => self.number_1(&children[0]), + 345 => self.integral_number_0(&children[0]), + 346 => self.integral_number_1(&children[0]), + 347 => self.integral_number_2(&children[0]), + 348 => self.real_number_0(&children[0]), + 349 => self.real_number_1(&children[0]), + 350 => self.hierarchical_identifier(&children[0], &children[1], &children[2]), + 351 => self.hierarchical_identifier_list0_0( &children[0], &children[1], &children[2], &children[3], ), - 346 => self.hierarchical_identifier_list0_list_0(&children[0], &children[1]), - 347 => self.hierarchical_identifier_list0_list_1(), - 348 => self.hierarchical_identifier_list0_1(), - 349 => self.hierarchical_identifier_list_0(&children[0], &children[1]), - 350 => self.hierarchical_identifier_list_1(), - 351 => self.scoped_identifier(&children[0], &children[1]), - 352 => self.scoped_identifier_group_0(&children[0]), - 353 => self.scoped_identifier_group_1(&children[0], &children[1]), - 354 => self.scoped_identifier_list_0( + 352 => self.hierarchical_identifier_list0_list_0(&children[0], &children[1]), + 353 => self.hierarchical_identifier_list0_list_1(), + 354 => self.hierarchical_identifier_list0_1(), + 355 => self.hierarchical_identifier_list_0(&children[0], &children[1]), + 356 => self.hierarchical_identifier_list_1(), + 357 => self.scoped_identifier(&children[0], &children[1]), + 358 => self.scoped_identifier_group_0(&children[0]), + 359 => self.scoped_identifier_group_1(&children[0], &children[1]), + 360 => self.scoped_identifier_list_0( &children[0], &children[1], &children[2], &children[3], ), - 355 => self.scoped_identifier_list_1(), - 356 => self.scoped_identifier_opt0_0(&children[0]), - 357 => self.scoped_identifier_opt0_1(), - 358 => self.scoped_identifier_opt_0(&children[0]), - 359 => self.scoped_identifier_opt_1(), - 360 => self.expression_identifier(&children[0], &children[1], &children[2]), - 361 => self.expression_identifier_list0_0( + 361 => self.scoped_identifier_list_1(), + 362 => self.scoped_identifier_opt0_0(&children[0]), + 363 => self.scoped_identifier_opt0_1(), + 364 => self.scoped_identifier_opt_0(&children[0]), + 365 => self.scoped_identifier_opt_1(), + 366 => self.expression_identifier(&children[0], &children[1], &children[2]), + 367 => self.expression_identifier_list0_0( &children[0], &children[1], &children[2], &children[3], ), - 362 => self.expression_identifier_list0_list_0(&children[0], &children[1]), - 363 => self.expression_identifier_list0_list_1(), - 364 => self.expression_identifier_list0_1(), - 365 => self.expression_identifier_list_0(&children[0], &children[1]), - 366 => self.expression_identifier_list_1(), - 367 => self.expression(&children[0], &children[1]), - 368 => self.expression_list_0(&children[0], &children[1], &children[2]), - 369 => self.expression_list_1(), - 370 => self.expression01(&children[0], &children[1]), - 371 => self.expression01_list_0(&children[0], &children[1], &children[2]), - 372 => self.expression01_list_1(), - 373 => self.expression02(&children[0], &children[1]), - 374 => self.expression02_list_0(&children[0], &children[1], &children[2]), - 375 => self.expression02_list_1(), - 376 => self.expression03(&children[0], &children[1]), - 377 => self.expression03_list_0(&children[0], &children[1], &children[2]), - 378 => self.expression03_list_1(), - 379 => self.expression04(&children[0], &children[1]), - 380 => self.expression04_list_0(&children[0], &children[1], &children[2]), - 381 => self.expression04_list_1(), - 382 => self.expression05(&children[0], &children[1]), - 383 => self.expression05_list_0(&children[0], &children[1], &children[2]), - 384 => self.expression05_list_1(), - 385 => self.expression06(&children[0], &children[1]), - 386 => self.expression06_list_0(&children[0], &children[1], &children[2]), - 387 => self.expression06_list_1(), - 388 => self.expression07(&children[0], &children[1]), - 389 => self.expression07_list_0(&children[0], &children[1], &children[2]), - 390 => self.expression07_list_1(), - 391 => self.expression08(&children[0], &children[1]), - 392 => self.expression08_list_0(&children[0], &children[1], &children[2]), - 393 => self.expression08_list_1(), - 394 => self.expression09(&children[0], &children[1]), - 395 => self.expression09_list_0(&children[0], &children[1], &children[2]), - 396 => self.expression09_list_group_0(&children[0]), - 397 => self.expression09_list_group_1(&children[0]), - 398 => self.expression09_list_1(), - 399 => self.expression10(&children[0], &children[1]), - 400 => self.expression10_list_0(&children[0], &children[1], &children[2]), - 401 => self.expression10_list_1(), - 402 => self.expression11(&children[0], &children[1]), - 403 => self.expression11_opt_0(&children[0], &children[1]), - 404 => self.expression11_opt_1(), - 405 => self.expression12(&children[0], &children[1]), - 406 => self.expression12_list_0(&children[0], &children[1]), - 407 => self.expression12_list_group_0(&children[0]), - 408 => self.expression12_list_group_1(&children[0]), - 409 => self.expression12_list_group_2(&children[0]), - 410 => self.expression12_list_group_3(&children[0]), - 411 => self.expression12_list_group_4(&children[0]), - 412 => self.expression12_list_1(), - 413 => self.factor_0(&children[0]), - 414 => self.factor_1(&children[0], &children[1]), - 415 => self.factor_2(&children[0], &children[1], &children[2]), - 416 => self.factor_3(&children[0], &children[1], &children[2]), - 417 => self.factor_4(&children[0], &children[1], &children[2]), - 418 => self.factor_5(&children[0]), - 419 => self.factor_6(&children[0]), - 420 => self.factor_7(&children[0]), - 421 => self.factor_8(&children[0]), - 422 => self.factor_9(&children[0]), - 423 => self.factor_group_0(&children[0]), - 424 => self.factor_group_1(&children[0]), - 425 => self.factor_10(&children[0]), - 426 => self.factor_11(&children[0]), - 427 => self.factor_opt_0(&children[0]), - 428 => self.factor_opt_1(), - 429 => self.function_call(&children[0], &children[1], &children[2]), - 430 => self.function_call_opt_0(&children[0]), - 431 => self.function_call_opt_1(), - 432 => self.argument_list(&children[0], &children[1], &children[2]), - 433 => self.argument_list_list_0(&children[0], &children[1], &children[2]), - 434 => self.argument_list_list_1(), - 435 => self.argument_list_opt_0(&children[0]), - 436 => self.argument_list_opt_1(), - 437 => self.argument_item(&children[0]), - 438 => self.concatenation_list(&children[0], &children[1], &children[2]), - 439 => self.concatenation_list_list_0(&children[0], &children[1], &children[2]), - 440 => self.concatenation_list_list_1(), - 441 => self.concatenation_list_opt_0(&children[0]), - 442 => self.concatenation_list_opt_1(), - 443 => self.concatenation_item(&children[0], &children[1]), - 444 => self.concatenation_item_opt_0(&children[0], &children[1]), - 445 => self.concatenation_item_opt_1(), - 446 => self.array_literal_list(&children[0], &children[1], &children[2]), - 447 => self.array_literal_list_list_0(&children[0], &children[1], &children[2]), - 448 => self.array_literal_list_list_1(), - 449 => self.array_literal_list_opt_0(&children[0]), - 450 => self.array_literal_list_opt_1(), - 451 => self.array_literal_item(&children[0]), - 452 => self.array_literal_item_group_0(&children[0], &children[1]), - 453 => self.array_literal_item_group_1(&children[0], &children[1], &children[2]), - 454 => self.array_literal_item_opt_0(&children[0], &children[1]), - 455 => self.array_literal_item_opt_1(), - 456 => self.if_expression( + 368 => self.expression_identifier_list0_list_0(&children[0], &children[1]), + 369 => self.expression_identifier_list0_list_1(), + 370 => self.expression_identifier_list0_1(), + 371 => self.expression_identifier_list_0(&children[0], &children[1]), + 372 => self.expression_identifier_list_1(), + 373 => self.expression(&children[0], &children[1]), + 374 => self.expression_list_0(&children[0], &children[1], &children[2]), + 375 => self.expression_list_1(), + 376 => self.expression01(&children[0], &children[1]), + 377 => self.expression01_list_0(&children[0], &children[1], &children[2]), + 378 => self.expression01_list_1(), + 379 => self.expression02(&children[0], &children[1]), + 380 => self.expression02_list_0(&children[0], &children[1], &children[2]), + 381 => self.expression02_list_1(), + 382 => self.expression03(&children[0], &children[1]), + 383 => self.expression03_list_0(&children[0], &children[1], &children[2]), + 384 => self.expression03_list_1(), + 385 => self.expression04(&children[0], &children[1]), + 386 => self.expression04_list_0(&children[0], &children[1], &children[2]), + 387 => self.expression04_list_1(), + 388 => self.expression05(&children[0], &children[1]), + 389 => self.expression05_list_0(&children[0], &children[1], &children[2]), + 390 => self.expression05_list_1(), + 391 => self.expression06(&children[0], &children[1]), + 392 => self.expression06_list_0(&children[0], &children[1], &children[2]), + 393 => self.expression06_list_1(), + 394 => self.expression07(&children[0], &children[1]), + 395 => self.expression07_list_0(&children[0], &children[1], &children[2]), + 396 => self.expression07_list_1(), + 397 => self.expression08(&children[0], &children[1]), + 398 => self.expression08_list_0(&children[0], &children[1], &children[2]), + 399 => self.expression08_list_1(), + 400 => self.expression09(&children[0], &children[1]), + 401 => self.expression09_list_0(&children[0], &children[1], &children[2]), + 402 => self.expression09_list_group_0(&children[0]), + 403 => self.expression09_list_group_1(&children[0]), + 404 => self.expression09_list_1(), + 405 => self.expression10(&children[0], &children[1]), + 406 => self.expression10_list_0(&children[0], &children[1], &children[2]), + 407 => self.expression10_list_1(), + 408 => self.expression11(&children[0], &children[1]), + 409 => self.expression11_opt_0(&children[0], &children[1]), + 410 => self.expression11_opt_1(), + 411 => self.expression12(&children[0], &children[1]), + 412 => self.expression12_list_0(&children[0], &children[1]), + 413 => self.expression12_list_group_0(&children[0]), + 414 => self.expression12_list_group_1(&children[0]), + 415 => self.expression12_list_group_2(&children[0]), + 416 => self.expression12_list_group_3(&children[0]), + 417 => self.expression12_list_group_4(&children[0]), + 418 => self.expression12_list_1(), + 419 => self.factor_0(&children[0]), + 420 => self.factor_1(&children[0], &children[1]), + 421 => self.factor_2(&children[0], &children[1], &children[2]), + 422 => self.factor_3(&children[0], &children[1], &children[2]), + 423 => self.factor_4(&children[0], &children[1], &children[2]), + 424 => self.factor_5(&children[0]), + 425 => self.factor_6(&children[0]), + 426 => self.factor_7(&children[0]), + 427 => self.factor_8(&children[0]), + 428 => self.factor_9(&children[0]), + 429 => self.factor_group_0(&children[0]), + 430 => self.factor_group_1(&children[0]), + 431 => self.factor_10(&children[0]), + 432 => self.factor_11(&children[0]), + 433 => self.factor_opt_0(&children[0]), + 434 => self.factor_opt_1(), + 435 => self.function_call(&children[0], &children[1], &children[2]), + 436 => self.function_call_opt_0(&children[0]), + 437 => self.function_call_opt_1(), + 438 => self.argument_list(&children[0], &children[1], &children[2]), + 439 => self.argument_list_list_0(&children[0], &children[1], &children[2]), + 440 => self.argument_list_list_1(), + 441 => self.argument_list_opt_0(&children[0]), + 442 => self.argument_list_opt_1(), + 443 => self.argument_item(&children[0]), + 444 => self.concatenation_list(&children[0], &children[1], &children[2]), + 445 => self.concatenation_list_list_0(&children[0], &children[1], &children[2]), + 446 => self.concatenation_list_list_1(), + 447 => self.concatenation_list_opt_0(&children[0]), + 448 => self.concatenation_list_opt_1(), + 449 => self.concatenation_item(&children[0], &children[1]), + 450 => self.concatenation_item_opt_0(&children[0], &children[1]), + 451 => self.concatenation_item_opt_1(), + 452 => self.array_literal_list(&children[0], &children[1], &children[2]), + 453 => self.array_literal_list_list_0(&children[0], &children[1], &children[2]), + 454 => self.array_literal_list_list_1(), + 455 => self.array_literal_list_opt_0(&children[0]), + 456 => self.array_literal_list_opt_1(), + 457 => self.array_literal_item(&children[0]), + 458 => self.array_literal_item_group_0(&children[0], &children[1]), + 459 => self.array_literal_item_group_1(&children[0], &children[1], &children[2]), + 460 => self.array_literal_item_opt_0(&children[0], &children[1]), + 461 => self.array_literal_item_opt_1(), + 462 => self.if_expression( &children[0], &children[1], &children[2], @@ -35621,7 +36236,7 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[8], &children[9], ), - 457 => self.if_expression_list_0( + 463 => self.if_expression_list_0( &children[0], &children[1], &children[2], @@ -35630,8 +36245,8 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 458 => self.if_expression_list_1(), - 459 => self.case_expression( + 464 => self.if_expression_list_1(), + 465 => self.case_expression( &children[0], &children[1], &children[2], @@ -35646,17 +36261,17 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[11], &children[12], ), - 460 => self.case_expression_list_0( + 466 => self.case_expression_list_0( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 461 => self.case_expression_list_1(), - 462 => self.case_expression_opt_0(&children[0]), - 463 => self.case_expression_opt_1(), - 464 => self.switch_expression( + 467 => self.case_expression_list_1(), + 468 => self.case_expression_opt_0(&children[0]), + 469 => self.case_expression_opt_1(), + 470 => self.switch_expression( &children[0], &children[1], &children[2], @@ -35670,113 +36285,112 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[10], &children[11], ), - 465 => self.switch_expression_list_0( + 471 => self.switch_expression_list_0( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 466 => self.switch_expression_list_1(), - 467 => self.switch_expression_opt_0(&children[0]), - 468 => self.switch_expression_opt_1(), - 469 => self.type_expression_0(&children[0]), - 470 => self.type_expression_1(&children[0], &children[1], &children[2], &children[3]), - 471 => self.inside_expression( + 472 => self.switch_expression_list_1(), + 473 => self.switch_expression_opt_0(&children[0]), + 474 => self.switch_expression_opt_1(), + 475 => self.type_expression_0(&children[0]), + 476 => self.type_expression_1(&children[0], &children[1], &children[2], &children[3]), + 477 => self.inside_expression( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 472 => self.outside_expression( + 478 => self.outside_expression( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 473 => self.range_list(&children[0], &children[1], &children[2]), - 474 => self.range_list_list_0(&children[0], &children[1], &children[2]), - 475 => self.range_list_list_1(), - 476 => self.range_list_opt_0(&children[0]), - 477 => self.range_list_opt_1(), - 478 => self.range_item(&children[0]), - 479 => self.select(&children[0], &children[1], &children[2], &children[3]), - 480 => self.select_opt_0(&children[0], &children[1]), - 481 => self.select_opt_1(), - 482 => self.select_operator_0(&children[0]), - 483 => self.select_operator_1(&children[0]), - 484 => self.select_operator_2(&children[0]), - 485 => self.select_operator_3(&children[0]), - 486 => self.width(&children[0], &children[1], &children[2], &children[3]), - 487 => self.width_list_0(&children[0], &children[1], &children[2]), - 488 => self.width_list_1(), - 489 => self.array(&children[0], &children[1], &children[2], &children[3]), - 490 => self.array_list_0(&children[0], &children[1], &children[2]), - 491 => self.array_list_1(), - 492 => self.range(&children[0], &children[1]), - 493 => self.range_opt_0(&children[0], &children[1]), - 494 => self.range_opt_1(), - 495 => self.range_operator_0(&children[0]), - 496 => self.range_operator_1(&children[0]), - 497 => self.fixed_type_0(&children[0]), - 498 => self.fixed_type_1(&children[0]), - 499 => self.fixed_type_2(&children[0]), - 500 => self.fixed_type_3(&children[0]), - 501 => self.fixed_type_4(&children[0]), - 502 => self.fixed_type_5(&children[0]), - 503 => self.fixed_type_6(&children[0]), - 504 => self.variable_type(&children[0], &children[1]), - 505 => self.variable_type_group_0(&children[0]), - 506 => self.variable_type_group_1(&children[0]), - 507 => self.variable_type_group_2(&children[0]), - 508 => self.variable_type_group_3(&children[0]), - 509 => self.variable_type_group_4(&children[0]), - 510 => self.variable_type_group_5(&children[0]), - 511 => self.variable_type_group_6(&children[0]), - 512 => self.variable_type_group_7(&children[0]), - 513 => self.variable_type_group_8(&children[0]), - 514 => self.variable_type_group_9(&children[0]), - 515 => self.variable_type_group_10(&children[0]), - 516 => self.variable_type_opt_0(&children[0]), - 517 => self.variable_type_opt_1(), - 518 => self.type_modifier_0(&children[0]), - 519 => self.type_modifier_1(&children[0]), - 520 => self.scalar_type(&children[0], &children[1]), - 521 => self.scalar_type_group_0(&children[0]), - 522 => self.scalar_type_group_1(&children[0]), - 523 => self.scalar_type_list_0(&children[0], &children[1]), - 524 => self.scalar_type_list_1(), - 525 => self.array_type(&children[0], &children[1]), - 526 => self.array_type_opt_0(&children[0]), - 527 => self.array_type_opt_1(), - 528 => self.casting_type_0(&children[0]), - 529 => self.casting_type_1(&children[0]), - 530 => self.casting_type_2(&children[0]), - 531 => self.casting_type_3(&children[0]), - 532 => self.casting_type_4(&children[0]), - 533 => self.casting_type_5(&children[0]), - 534 => self.casting_type_6(&children[0]), - 535 => self.casting_type_7(&children[0]), - 536 => self.casting_type_8(&children[0]), - 537 => self.casting_type_9(&children[0]), - 538 => self.casting_type_10(&children[0]), - 539 => self.casting_type_11(&children[0]), - 540 => self.casting_type_12(&children[0]), - 541 => self.casting_type_13(&children[0]), - 542 => self.casting_type_14(&children[0]), - 543 => self.clock_domain(&children[0], &children[1]), - 544 => self.statement_0(&children[0]), - 545 => self.statement_1(&children[0]), - 546 => self.statement_2(&children[0]), - 547 => self.statement_3(&children[0]), - 548 => self.statement_4(&children[0]), - 549 => self.statement_5(&children[0]), - 550 => self.statement_6(&children[0]), - 551 => self.statement_7(&children[0]), - 552 => self.statement_8(&children[0]), - 553 => self.let_statement( + 479 => self.range_list(&children[0], &children[1], &children[2]), + 480 => self.range_list_list_0(&children[0], &children[1], &children[2]), + 481 => self.range_list_list_1(), + 482 => self.range_list_opt_0(&children[0]), + 483 => self.range_list_opt_1(), + 484 => self.range_item(&children[0]), + 485 => self.select(&children[0], &children[1], &children[2], &children[3]), + 486 => self.select_opt_0(&children[0], &children[1]), + 487 => self.select_opt_1(), + 488 => self.select_operator_0(&children[0]), + 489 => self.select_operator_1(&children[0]), + 490 => self.select_operator_2(&children[0]), + 491 => self.select_operator_3(&children[0]), + 492 => self.width(&children[0], &children[1], &children[2], &children[3]), + 493 => self.width_list_0(&children[0], &children[1], &children[2]), + 494 => self.width_list_1(), + 495 => self.array(&children[0], &children[1], &children[2], &children[3]), + 496 => self.array_list_0(&children[0], &children[1], &children[2]), + 497 => self.array_list_1(), + 498 => self.range(&children[0], &children[1]), + 499 => self.range_opt_0(&children[0], &children[1]), + 500 => self.range_opt_1(), + 501 => self.range_operator_0(&children[0]), + 502 => self.range_operator_1(&children[0]), + 503 => self.fixed_type_0(&children[0]), + 504 => self.fixed_type_1(&children[0]), + 505 => self.fixed_type_2(&children[0]), + 506 => self.fixed_type_3(&children[0]), + 507 => self.fixed_type_4(&children[0]), + 508 => self.fixed_type_5(&children[0]), + 509 => self.fixed_type_6(&children[0]), + 510 => self.variable_type_0(&children[0]), + 511 => self.variable_type_1(&children[0]), + 512 => self.variable_type_2(&children[0]), + 513 => self.variable_type_3(&children[0]), + 514 => self.variable_type_4(&children[0]), + 515 => self.variable_type_5(&children[0]), + 516 => self.variable_type_6(&children[0]), + 517 => self.variable_type_7(&children[0]), + 518 => self.variable_type_8(&children[0]), + 519 => self.variable_type_9(&children[0]), + 520 => self.variable_type_10(&children[0]), + 521 => self.type_modifier_0(&children[0]), + 522 => self.type_modifier_1(&children[0]), + 523 => self.scalar_type(&children[0], &children[1]), + 524 => self.scalar_type_group_0(&children[0], &children[1]), + 525 => self.scalar_type_group_1(&children[0]), + 526 => self.scalar_type_list_0(&children[0], &children[1]), + 527 => self.scalar_type_list_1(), + 528 => self.scalar_type_opt_0(&children[0]), + 529 => self.scalar_type_opt_1(), + 530 => self.array_type(&children[0], &children[1]), + 531 => self.array_type_opt_0(&children[0]), + 532 => self.array_type_opt_1(), + 533 => self.casting_type_0(&children[0]), + 534 => self.casting_type_1(&children[0]), + 535 => self.casting_type_2(&children[0]), + 536 => self.casting_type_3(&children[0]), + 537 => self.casting_type_4(&children[0]), + 538 => self.casting_type_5(&children[0]), + 539 => self.casting_type_6(&children[0]), + 540 => self.casting_type_7(&children[0]), + 541 => self.casting_type_8(&children[0]), + 542 => self.casting_type_9(&children[0]), + 543 => self.casting_type_10(&children[0]), + 544 => self.casting_type_11(&children[0]), + 545 => self.casting_type_12(&children[0]), + 546 => self.casting_type_13(&children[0]), + 547 => self.casting_type_14(&children[0]), + 548 => self.clock_domain(&children[0], &children[1]), + 549 => self.statement_0(&children[0]), + 550 => self.statement_1(&children[0]), + 551 => self.statement_2(&children[0]), + 552 => self.statement_3(&children[0]), + 553 => self.statement_4(&children[0]), + 554 => self.statement_5(&children[0]), + 555 => self.statement_6(&children[0]), + 556 => self.statement_7(&children[0]), + 557 => self.statement_8(&children[0]), + 558 => self.let_statement( &children[0], &children[1], &children[2], @@ -35786,15 +36400,15 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 554 => self.let_statement_opt_0(&children[0]), - 555 => self.let_statement_opt_1(), - 556 => self.identifier_statement(&children[0], &children[1], &children[2]), - 557 => self.identifier_statement_group_0(&children[0]), - 558 => self.identifier_statement_group_1(&children[0]), - 559 => self.assignment(&children[0], &children[1]), - 560 => self.assignment_group_0(&children[0]), - 561 => self.assignment_group_1(&children[0]), - 562 => self.if_statement( + 559 => self.let_statement_opt_0(&children[0]), + 560 => self.let_statement_opt_1(), + 561 => self.identifier_statement(&children[0], &children[1], &children[2]), + 562 => self.identifier_statement_group_0(&children[0]), + 563 => self.identifier_statement_group_1(&children[0]), + 564 => self.assignment(&children[0], &children[1]), + 565 => self.assignment_group_0(&children[0]), + 566 => self.assignment_group_1(&children[0]), + 567 => self.if_statement( &children[0], &children[1], &children[2], @@ -35803,7 +36417,7 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 563 => self.if_statement_list0_0( + 568 => self.if_statement_list0_0( &children[0], &children[1], &children[2], @@ -35812,16 +36426,16 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 564 => self.if_statement_list0_list_0(&children[0], &children[1]), - 565 => self.if_statement_list0_list_1(), - 566 => self.if_statement_list0_1(), - 567 => self.if_statement_list_0(&children[0], &children[1]), - 568 => self.if_statement_list_1(), - 569 => self.if_statement_opt_0(&children[0], &children[1], &children[2], &children[3]), - 570 => self.if_statement_opt_list_0(&children[0], &children[1]), - 571 => self.if_statement_opt_list_1(), - 572 => self.if_statement_opt_1(), - 573 => self.if_reset_statement( + 569 => self.if_statement_list0_list_0(&children[0], &children[1]), + 570 => self.if_statement_list0_list_1(), + 571 => self.if_statement_list0_1(), + 572 => self.if_statement_list_0(&children[0], &children[1]), + 573 => self.if_statement_list_1(), + 574 => self.if_statement_opt_0(&children[0], &children[1], &children[2], &children[3]), + 575 => self.if_statement_opt_list_0(&children[0], &children[1]), + 576 => self.if_statement_opt_list_1(), + 577 => self.if_statement_opt_1(), + 578 => self.if_reset_statement( &children[0], &children[1], &children[2], @@ -35829,7 +36443,7 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 574 => self.if_reset_statement_list0_0( + 579 => self.if_reset_statement_list0_0( &children[0], &children[1], &children[2], @@ -35838,23 +36452,23 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 575 => self.if_reset_statement_list0_list_0(&children[0], &children[1]), - 576 => self.if_reset_statement_list0_list_1(), - 577 => self.if_reset_statement_list0_1(), - 578 => self.if_reset_statement_list_0(&children[0], &children[1]), - 579 => self.if_reset_statement_list_1(), - 580 => self.if_reset_statement_opt_0( + 580 => self.if_reset_statement_list0_list_0(&children[0], &children[1]), + 581 => self.if_reset_statement_list0_list_1(), + 582 => self.if_reset_statement_list0_1(), + 583 => self.if_reset_statement_list_0(&children[0], &children[1]), + 584 => self.if_reset_statement_list_1(), + 585 => self.if_reset_statement_opt_0( &children[0], &children[1], &children[2], &children[3], ), - 581 => self.if_reset_statement_opt_list_0(&children[0], &children[1]), - 582 => self.if_reset_statement_opt_list_1(), - 583 => self.if_reset_statement_opt_1(), - 584 => self.return_statement(&children[0], &children[1], &children[2]), - 585 => self.break_statement(&children[0], &children[1]), - 586 => self.for_statement( + 586 => self.if_reset_statement_opt_list_0(&children[0], &children[1]), + 587 => self.if_reset_statement_opt_list_1(), + 588 => self.if_reset_statement_opt_1(), + 589 => self.return_statement(&children[0], &children[1], &children[2]), + 590 => self.break_statement(&children[0], &children[1]), + 591 => self.for_statement( &children[0], &children[1], &children[2], @@ -35866,59 +36480,59 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[8], &children[9], ), - 587 => self.for_statement_list_0(&children[0], &children[1]), - 588 => self.for_statement_list_1(), - 589 => self.for_statement_opt_0(&children[0], &children[1], &children[2]), - 590 => self.for_statement_opt_1(), - 591 => self.case_statement( + 592 => self.for_statement_list_0(&children[0], &children[1]), + 593 => self.for_statement_list_1(), + 594 => self.for_statement_opt_0(&children[0], &children[1], &children[2]), + 595 => self.for_statement_opt_1(), + 596 => self.case_statement( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 592 => self.case_statement_list_0(&children[0], &children[1]), - 593 => self.case_statement_list_1(), - 594 => self.case_item(&children[0], &children[1], &children[2]), - 595 => self.case_item_group0_0(&children[0]), - 596 => self.case_item_group0_1(&children[0], &children[1], &children[2]), - 597 => self.case_item_group0_list_0(&children[0], &children[1]), - 598 => self.case_item_group0_list_1(), - 599 => self.case_item_group_0(&children[0]), - 600 => self.case_item_group_1(&children[0]), - 601 => self.case_condition(&children[0], &children[1]), - 602 => self.case_condition_list_0(&children[0], &children[1], &children[2]), - 603 => self.case_condition_list_1(), - 604 => self.switch_statement(&children[0], &children[1], &children[2], &children[3]), - 605 => self.switch_statement_list_0(&children[0], &children[1]), - 606 => self.switch_statement_list_1(), - 607 => self.switch_item(&children[0], &children[1], &children[2]), - 608 => self.switch_item_group0_0(&children[0]), - 609 => self.switch_item_group0_1(&children[0], &children[1], &children[2]), - 610 => self.switch_item_group0_list_0(&children[0], &children[1]), - 611 => self.switch_item_group0_list_1(), - 612 => self.switch_item_group_0(&children[0]), - 613 => self.switch_item_group_1(&children[0]), - 614 => self.switch_condition(&children[0], &children[1]), - 615 => self.switch_condition_list_0(&children[0], &children[1], &children[2]), - 616 => self.switch_condition_list_1(), - 617 => self.attribute( + 597 => self.case_statement_list_0(&children[0], &children[1]), + 598 => self.case_statement_list_1(), + 599 => self.case_item(&children[0], &children[1], &children[2]), + 600 => self.case_item_group0_0(&children[0]), + 601 => self.case_item_group0_1(&children[0], &children[1], &children[2]), + 602 => self.case_item_group0_list_0(&children[0], &children[1]), + 603 => self.case_item_group0_list_1(), + 604 => self.case_item_group_0(&children[0]), + 605 => self.case_item_group_1(&children[0]), + 606 => self.case_condition(&children[0], &children[1]), + 607 => self.case_condition_list_0(&children[0], &children[1], &children[2]), + 608 => self.case_condition_list_1(), + 609 => self.switch_statement(&children[0], &children[1], &children[2], &children[3]), + 610 => self.switch_statement_list_0(&children[0], &children[1]), + 611 => self.switch_statement_list_1(), + 612 => self.switch_item(&children[0], &children[1], &children[2]), + 613 => self.switch_item_group0_0(&children[0]), + 614 => self.switch_item_group0_1(&children[0], &children[1], &children[2]), + 615 => self.switch_item_group0_list_0(&children[0], &children[1]), + 616 => self.switch_item_group0_list_1(), + 617 => self.switch_item_group_0(&children[0]), + 618 => self.switch_item_group_1(&children[0]), + 619 => self.switch_condition(&children[0], &children[1]), + 620 => self.switch_condition_list_0(&children[0], &children[1], &children[2]), + 621 => self.switch_condition_list_1(), + 622 => self.attribute( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 618 => self.attribute_opt_0(&children[0], &children[1], &children[2]), - 619 => self.attribute_opt_1(), - 620 => self.attribute_list(&children[0], &children[1], &children[2]), - 621 => self.attribute_list_list_0(&children[0], &children[1], &children[2]), - 622 => self.attribute_list_list_1(), - 623 => self.attribute_list_opt_0(&children[0]), - 624 => self.attribute_list_opt_1(), - 625 => self.attribute_item_0(&children[0]), - 626 => self.attribute_item_1(&children[0]), - 627 => self.let_declaration( + 623 => self.attribute_opt_0(&children[0], &children[1], &children[2]), + 624 => self.attribute_opt_1(), + 625 => self.attribute_list(&children[0], &children[1], &children[2]), + 626 => self.attribute_list_list_0(&children[0], &children[1], &children[2]), + 627 => self.attribute_list_list_1(), + 628 => self.attribute_list_opt_0(&children[0]), + 629 => self.attribute_list_opt_1(), + 630 => self.attribute_item_0(&children[0]), + 631 => self.attribute_item_1(&children[0]), + 632 => self.let_declaration( &children[0], &children[1], &children[2], @@ -35928,9 +36542,9 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 628 => self.let_declaration_opt_0(&children[0]), - 629 => self.let_declaration_opt_1(), - 630 => self.var_declaration( + 633 => self.let_declaration_opt_0(&children[0]), + 634 => self.let_declaration_opt_1(), + 635 => self.var_declaration( &children[0], &children[1], &children[2], @@ -35938,73 +36552,73 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 631 => self.var_declaration_opt_0(&children[0]), - 632 => self.var_declaration_opt_1(), - 633 => self.local_declaration( + 636 => self.var_declaration_opt_0(&children[0]), + 637 => self.var_declaration_opt_1(), + 638 => self.local_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 634 => self.local_declaration_group_0(&children[0], &children[1], &children[2]), - 635 => self.local_declaration_group_1(&children[0], &children[1], &children[2]), - 636 => self.type_def_declaration( + 639 => self.local_declaration_group_0(&children[0], &children[1], &children[2]), + 640 => self.local_declaration_group_1(&children[0], &children[1], &children[2]), + 641 => self.type_def_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 637 => self.always_ff_declaration( + 642 => self.always_ff_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 638 => self.always_ff_declaration_list_0(&children[0], &children[1]), - 639 => self.always_ff_declaration_list_1(), - 640 => self.always_ff_declaration_opt_0(&children[0]), - 641 => self.always_ff_declaration_opt_1(), - 642 => { + 643 => self.always_ff_declaration_list_0(&children[0], &children[1]), + 644 => self.always_ff_declaration_list_1(), + 645 => self.always_ff_declaration_opt_0(&children[0]), + 646 => self.always_ff_declaration_opt_1(), + 647 => { self.alwayf_ff_event_list(&children[0], &children[1], &children[2], &children[3]) } - 643 => self.alwayf_ff_event_list_opt_0(&children[0], &children[1]), - 644 => self.alwayf_ff_event_list_opt_1(), - 645 => self.always_ff_clock(&children[0]), - 646 => self.always_ff_reset(&children[0]), - 647 => { + 648 => self.alwayf_ff_event_list_opt_0(&children[0], &children[1]), + 649 => self.alwayf_ff_event_list_opt_1(), + 650 => self.always_ff_clock(&children[0]), + 651 => self.always_ff_reset(&children[0]), + 652 => { self.always_comb_declaration(&children[0], &children[1], &children[2], &children[3]) } - 648 => self.always_comb_declaration_list_0(&children[0], &children[1]), - 649 => self.always_comb_declaration_list_1(), - 650 => self.assign_declaration( + 653 => self.always_comb_declaration_list_0(&children[0], &children[1]), + 654 => self.always_comb_declaration_list_1(), + 655 => self.assign_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 651 => self.modport_declaration( + 656 => self.modport_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 652 => self.modport_list(&children[0], &children[1], &children[2]), - 653 => self.modport_list_list_0(&children[0], &children[1], &children[2]), - 654 => self.modport_list_list_1(), - 655 => self.modport_list_opt_0(&children[0]), - 656 => self.modport_list_opt_1(), - 657 => self.modport_group(&children[0], &children[1]), - 658 => self.modport_group_group_0(&children[0], &children[1], &children[2]), - 659 => self.modport_group_group_1(&children[0]), - 660 => self.modport_group_list_0(&children[0], &children[1]), - 661 => self.modport_group_list_1(), - 662 => self.modport_item(&children[0], &children[1], &children[2]), - 663 => self.enum_declaration( + 657 => self.modport_list(&children[0], &children[1], &children[2]), + 658 => self.modport_list_list_0(&children[0], &children[1], &children[2]), + 659 => self.modport_list_list_1(), + 660 => self.modport_list_opt_0(&children[0]), + 661 => self.modport_list_opt_1(), + 662 => self.modport_group(&children[0], &children[1]), + 663 => self.modport_group_group_0(&children[0], &children[1], &children[2]), + 664 => self.modport_group_group_1(&children[0]), + 665 => self.modport_group_list_0(&children[0], &children[1]), + 666 => self.modport_group_list_1(), + 667 => self.modport_item(&children[0], &children[1], &children[2]), + 668 => self.enum_declaration( &children[0], &children[1], &children[2], @@ -36012,24 +36626,24 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 664 => self.enum_declaration_opt_0(&children[0], &children[1]), - 665 => self.enum_declaration_opt_1(), - 666 => self.enum_list(&children[0], &children[1], &children[2]), - 667 => self.enum_list_list_0(&children[0], &children[1], &children[2]), - 668 => self.enum_list_list_1(), - 669 => self.enum_list_opt_0(&children[0]), - 670 => self.enum_list_opt_1(), - 671 => self.enum_group(&children[0], &children[1]), - 672 => self.enum_group_group_0(&children[0], &children[1], &children[2]), - 673 => self.enum_group_group_1(&children[0]), - 674 => self.enum_group_list_0(&children[0], &children[1]), - 675 => self.enum_group_list_1(), - 676 => self.enum_item(&children[0], &children[1]), - 677 => self.enum_item_opt_0(&children[0], &children[1]), - 678 => self.enum_item_opt_1(), - 679 => self.struct_union_0(&children[0]), - 680 => self.struct_union_1(&children[0]), - 681 => self.struct_union_declaration( + 669 => self.enum_declaration_opt_0(&children[0], &children[1]), + 670 => self.enum_declaration_opt_1(), + 671 => self.enum_list(&children[0], &children[1], &children[2]), + 672 => self.enum_list_list_0(&children[0], &children[1], &children[2]), + 673 => self.enum_list_list_1(), + 674 => self.enum_list_opt_0(&children[0]), + 675 => self.enum_list_opt_1(), + 676 => self.enum_group(&children[0], &children[1]), + 677 => self.enum_group_group_0(&children[0], &children[1], &children[2]), + 678 => self.enum_group_group_1(&children[0]), + 679 => self.enum_group_list_0(&children[0], &children[1]), + 680 => self.enum_group_list_1(), + 681 => self.enum_item(&children[0], &children[1]), + 682 => self.enum_item_opt_0(&children[0], &children[1]), + 683 => self.enum_item_opt_1(), + 684 => self.struct_union_0(&children[0]), + 685 => self.struct_union_1(&children[0]), + 686 => self.struct_union_declaration( &children[0], &children[1], &children[2], @@ -36037,26 +36651,26 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 682 => self.struct_union_declaration_opt_0(&children[0]), - 683 => self.struct_union_declaration_opt_1(), - 684 => self.struct_union_list(&children[0], &children[1], &children[2]), - 685 => self.struct_union_list_list_0(&children[0], &children[1], &children[2]), - 686 => self.struct_union_list_list_1(), - 687 => self.struct_union_list_opt_0(&children[0]), - 688 => self.struct_union_list_opt_1(), - 689 => self.struct_union_group(&children[0], &children[1]), - 690 => self.struct_union_group_group_0(&children[0], &children[1], &children[2]), - 691 => self.struct_union_group_group_1(&children[0]), - 692 => self.struct_union_group_list_0(&children[0], &children[1]), - 693 => self.struct_union_group_list_1(), - 694 => self.struct_union_item(&children[0], &children[1], &children[2]), - 695 => self.initial_declaration(&children[0], &children[1], &children[2], &children[3]), - 696 => self.initial_declaration_list_0(&children[0], &children[1]), - 697 => self.initial_declaration_list_1(), - 698 => self.final_declaration(&children[0], &children[1], &children[2], &children[3]), - 699 => self.final_declaration_list_0(&children[0], &children[1]), - 700 => self.final_declaration_list_1(), - 701 => self.inst_declaration( + 687 => self.struct_union_declaration_opt_0(&children[0]), + 688 => self.struct_union_declaration_opt_1(), + 689 => self.struct_union_list(&children[0], &children[1], &children[2]), + 690 => self.struct_union_list_list_0(&children[0], &children[1], &children[2]), + 691 => self.struct_union_list_list_1(), + 692 => self.struct_union_list_opt_0(&children[0]), + 693 => self.struct_union_list_opt_1(), + 694 => self.struct_union_group(&children[0], &children[1]), + 695 => self.struct_union_group_group_0(&children[0], &children[1], &children[2]), + 696 => self.struct_union_group_group_1(&children[0]), + 697 => self.struct_union_group_list_0(&children[0], &children[1]), + 698 => self.struct_union_group_list_1(), + 699 => self.struct_union_item(&children[0], &children[1], &children[2]), + 700 => self.initial_declaration(&children[0], &children[1], &children[2], &children[3]), + 701 => self.initial_declaration_list_0(&children[0], &children[1]), + 702 => self.initial_declaration_list_1(), + 703 => self.final_declaration(&children[0], &children[1], &children[2], &children[3]), + 704 => self.final_declaration_list_0(&children[0], &children[1]), + 705 => self.final_declaration_list_1(), + 706 => self.inst_declaration( &children[0], &children[1], &children[2], @@ -36066,113 +36680,121 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 702 => self.inst_declaration_opt1_0(&children[0], &children[1], &children[2]), - 703 => self.inst_declaration_opt2_0(&children[0]), - 704 => self.inst_declaration_opt2_1(), - 705 => self.inst_declaration_opt1_1(), - 706 => self.inst_declaration_opt0_0(&children[0]), - 707 => self.inst_declaration_opt0_1(), - 708 => self.inst_declaration_opt_0(&children[0]), - 709 => self.inst_declaration_opt_1(), - 710 => self.inst_parameter(&children[0], &children[1], &children[2], &children[3]), - 711 => self.inst_parameter_opt_0(&children[0]), - 712 => self.inst_parameter_opt_1(), - 713 => self.inst_parameter_list(&children[0], &children[1], &children[2]), - 714 => self.inst_parameter_list_list_0(&children[0], &children[1], &children[2]), - 715 => self.inst_parameter_list_list_1(), - 716 => self.inst_parameter_list_opt_0(&children[0]), - 717 => self.inst_parameter_list_opt_1(), - 718 => self.inst_parameter_group(&children[0], &children[1]), - 719 => self.inst_parameter_group_group_0(&children[0], &children[1], &children[2]), - 720 => self.inst_parameter_group_group_1(&children[0]), - 721 => self.inst_parameter_group_list_0(&children[0], &children[1]), - 722 => self.inst_parameter_group_list_1(), - 723 => self.inst_parameter_item(&children[0], &children[1]), - 724 => self.inst_parameter_item_opt_0(&children[0], &children[1]), - 725 => self.inst_parameter_item_opt_1(), - 726 => self.inst_port_list(&children[0], &children[1], &children[2]), - 727 => self.inst_port_list_list_0(&children[0], &children[1], &children[2]), - 728 => self.inst_port_list_list_1(), - 729 => self.inst_port_list_opt_0(&children[0]), - 730 => self.inst_port_list_opt_1(), - 731 => self.inst_port_group(&children[0], &children[1]), - 732 => self.inst_port_group_group_0(&children[0], &children[1], &children[2]), - 733 => self.inst_port_group_group_1(&children[0]), - 734 => self.inst_port_group_list_0(&children[0], &children[1]), - 735 => self.inst_port_group_list_1(), - 736 => self.inst_port_item(&children[0], &children[1]), - 737 => self.inst_port_item_opt_0(&children[0], &children[1]), - 738 => self.inst_port_item_opt_1(), - 739 => self.with_parameter(&children[0], &children[1], &children[2], &children[3]), - 740 => self.with_parameter_opt_0(&children[0]), - 741 => self.with_parameter_opt_1(), - 742 => self.with_parameter_list(&children[0], &children[1], &children[2]), - 743 => self.with_parameter_list_list_0(&children[0], &children[1], &children[2]), - 744 => self.with_parameter_list_list_1(), - 745 => self.with_parameter_list_opt_0(&children[0]), - 746 => self.with_parameter_list_opt_1(), - 747 => self.with_parameter_group(&children[0], &children[1]), - 748 => self.with_parameter_group_group_0(&children[0], &children[1], &children[2]), - 749 => self.with_parameter_group_group_1(&children[0]), - 750 => self.with_parameter_group_list_0(&children[0], &children[1]), - 751 => self.with_parameter_group_list_1(), - 752 => self.with_parameter_item(&children[0], &children[1], &children[2], &children[3]), - 753 => self.with_parameter_item_group0_0(&children[0], &children[1], &children[2]), - 754 => self.with_parameter_item_group0_1(&children[0], &children[1], &children[2]), - 755 => self.with_parameter_item_group_0(&children[0]), - 756 => self.with_parameter_item_group_1(&children[0]), - 757 => self.with_generic_parameter(&children[0], &children[1], &children[2]), - 758 => self.with_generic_parameter_list(&children[0], &children[1], &children[2]), - 759 => { + 707 => self.inst_declaration_opt1_0(&children[0], &children[1], &children[2]), + 708 => self.inst_declaration_opt2_0(&children[0]), + 709 => self.inst_declaration_opt2_1(), + 710 => self.inst_declaration_opt1_1(), + 711 => self.inst_declaration_opt0_0(&children[0]), + 712 => self.inst_declaration_opt0_1(), + 713 => self.inst_declaration_opt_0(&children[0]), + 714 => self.inst_declaration_opt_1(), + 715 => self.inst_parameter(&children[0], &children[1], &children[2], &children[3]), + 716 => self.inst_parameter_opt_0(&children[0]), + 717 => self.inst_parameter_opt_1(), + 718 => self.inst_parameter_list(&children[0], &children[1], &children[2]), + 719 => self.inst_parameter_list_list_0(&children[0], &children[1], &children[2]), + 720 => self.inst_parameter_list_list_1(), + 721 => self.inst_parameter_list_opt_0(&children[0]), + 722 => self.inst_parameter_list_opt_1(), + 723 => self.inst_parameter_group(&children[0], &children[1]), + 724 => self.inst_parameter_group_group_0(&children[0], &children[1], &children[2]), + 725 => self.inst_parameter_group_group_1(&children[0]), + 726 => self.inst_parameter_group_list_0(&children[0], &children[1]), + 727 => self.inst_parameter_group_list_1(), + 728 => self.inst_parameter_item(&children[0], &children[1]), + 729 => self.inst_parameter_item_opt_0(&children[0], &children[1]), + 730 => self.inst_parameter_item_opt_1(), + 731 => self.inst_port_list(&children[0], &children[1], &children[2]), + 732 => self.inst_port_list_list_0(&children[0], &children[1], &children[2]), + 733 => self.inst_port_list_list_1(), + 734 => self.inst_port_list_opt_0(&children[0]), + 735 => self.inst_port_list_opt_1(), + 736 => self.inst_port_group(&children[0], &children[1]), + 737 => self.inst_port_group_group_0(&children[0], &children[1], &children[2]), + 738 => self.inst_port_group_group_1(&children[0]), + 739 => self.inst_port_group_list_0(&children[0], &children[1]), + 740 => self.inst_port_group_list_1(), + 741 => self.inst_port_item(&children[0], &children[1]), + 742 => self.inst_port_item_opt_0(&children[0], &children[1]), + 743 => self.inst_port_item_opt_1(), + 744 => self.with_parameter(&children[0], &children[1], &children[2], &children[3]), + 745 => self.with_parameter_opt_0(&children[0]), + 746 => self.with_parameter_opt_1(), + 747 => self.with_parameter_list(&children[0], &children[1], &children[2]), + 748 => self.with_parameter_list_list_0(&children[0], &children[1], &children[2]), + 749 => self.with_parameter_list_list_1(), + 750 => self.with_parameter_list_opt_0(&children[0]), + 751 => self.with_parameter_list_opt_1(), + 752 => self.with_parameter_group(&children[0], &children[1]), + 753 => self.with_parameter_group_group_0(&children[0], &children[1], &children[2]), + 754 => self.with_parameter_group_group_1(&children[0]), + 755 => self.with_parameter_group_list_0(&children[0], &children[1]), + 756 => self.with_parameter_group_list_1(), + 757 => self.with_parameter_item(&children[0], &children[1], &children[2], &children[3]), + 758 => self.with_parameter_item_group0_0(&children[0], &children[1], &children[2]), + 759 => self.with_parameter_item_group0_1(&children[0], &children[1], &children[2]), + 760 => self.with_parameter_item_group_0(&children[0]), + 761 => self.with_parameter_item_group_1(&children[0]), + 762 => self.generic_bound_0(&children[0]), + 763 => self.generic_bound_1(&children[0]), + 764 => self.generic_bound_2(&children[0]), + 765 => self.with_generic_parameter(&children[0], &children[1], &children[2]), + 766 => self.with_generic_parameter_list(&children[0], &children[1], &children[2]), + 767 => { self.with_generic_parameter_list_list_0(&children[0], &children[1], &children[2]) } - 760 => self.with_generic_parameter_list_list_1(), - 761 => self.with_generic_parameter_list_opt_0(&children[0]), - 762 => self.with_generic_parameter_list_opt_1(), - 763 => self.with_generic_parameter_item(&children[0], &children[1]), - 764 => self.with_generic_parameter_item_opt_0(&children[0], &children[1]), - 765 => self.with_generic_parameter_item_opt_1(), - 766 => self.with_generic_argument(&children[0], &children[1], &children[2]), - 767 => self.with_generic_argument_opt_0(&children[0]), - 768 => self.with_generic_argument_opt_1(), - 769 => self.with_generic_argument_list(&children[0], &children[1], &children[2]), - 770 => self.with_generic_argument_list_list_0(&children[0], &children[1], &children[2]), - 771 => self.with_generic_argument_list_list_1(), - 772 => self.with_generic_argument_list_opt_0(&children[0]), - 773 => self.with_generic_argument_list_opt_1(), - 774 => self.with_generic_argument_item_0(&children[0]), - 775 => self.with_generic_argument_item_1(&children[0]), - 776 => self.port_declaration(&children[0], &children[1], &children[2]), - 777 => self.port_declaration_opt_0(&children[0]), - 778 => self.port_declaration_opt_1(), - 779 => self.port_declaration_list(&children[0], &children[1], &children[2]), - 780 => self.port_declaration_list_list_0(&children[0], &children[1], &children[2]), - 781 => self.port_declaration_list_list_1(), - 782 => self.port_declaration_list_opt_0(&children[0]), - 783 => self.port_declaration_list_opt_1(), - 784 => self.port_declaration_group(&children[0], &children[1]), - 785 => self.port_declaration_group_group_0(&children[0], &children[1], &children[2]), - 786 => self.port_declaration_group_group_1(&children[0]), - 787 => self.port_declaration_group_list_0(&children[0], &children[1]), - 788 => self.port_declaration_group_list_1(), - 789 => self.port_declaration_item(&children[0], &children[1], &children[2]), - 790 => self.port_declaration_item_group_0(&children[0]), - 791 => self.port_declaration_item_group_1(&children[0]), - 792 => self.port_type_concrete(&children[0], &children[1], &children[2]), - 793 => self.port_type_concrete_opt_0(&children[0]), - 794 => self.port_type_concrete_opt_1(), - 795 => self.port_type_abstract(&children[0], &children[1], &children[2]), - 796 => self.port_type_abstract_opt0_0(&children[0]), - 797 => self.port_type_abstract_opt0_1(), - 798 => self.port_type_abstract_opt_0(&children[0]), - 799 => self.port_type_abstract_opt_1(), - 800 => self.direction_0(&children[0]), - 801 => self.direction_1(&children[0]), - 802 => self.direction_2(&children[0]), - 803 => self.direction_3(&children[0]), - 804 => self.direction_4(&children[0]), - 805 => self.direction_5(&children[0]), - 806 => self.function_declaration( + 768 => self.with_generic_parameter_list_list_1(), + 769 => self.with_generic_parameter_list_opt_0(&children[0]), + 770 => self.with_generic_parameter_list_opt_1(), + 771 => self.with_generic_parameter_item( + &children[0], + &children[1], + &children[2], + &children[3], + ), + 772 => self.with_generic_parameter_item_opt_0(&children[0], &children[1]), + 773 => self.with_generic_parameter_item_opt_1(), + 774 => self.with_generic_argument(&children[0], &children[1], &children[2]), + 775 => self.with_generic_argument_opt_0(&children[0]), + 776 => self.with_generic_argument_opt_1(), + 777 => self.with_generic_argument_list(&children[0], &children[1], &children[2]), + 778 => self.with_generic_argument_list_list_0(&children[0], &children[1], &children[2]), + 779 => self.with_generic_argument_list_list_1(), + 780 => self.with_generic_argument_list_opt_0(&children[0]), + 781 => self.with_generic_argument_list_opt_1(), + 782 => self.with_generic_argument_item_0(&children[0]), + 783 => self.with_generic_argument_item_1(&children[0]), + 784 => self.port_declaration(&children[0], &children[1], &children[2]), + 785 => self.port_declaration_opt_0(&children[0]), + 786 => self.port_declaration_opt_1(), + 787 => self.port_declaration_list(&children[0], &children[1], &children[2]), + 788 => self.port_declaration_list_list_0(&children[0], &children[1], &children[2]), + 789 => self.port_declaration_list_list_1(), + 790 => self.port_declaration_list_opt_0(&children[0]), + 791 => self.port_declaration_list_opt_1(), + 792 => self.port_declaration_group(&children[0], &children[1]), + 793 => self.port_declaration_group_group_0(&children[0], &children[1], &children[2]), + 794 => self.port_declaration_group_group_1(&children[0]), + 795 => self.port_declaration_group_list_0(&children[0], &children[1]), + 796 => self.port_declaration_group_list_1(), + 797 => self.port_declaration_item(&children[0], &children[1], &children[2]), + 798 => self.port_declaration_item_group_0(&children[0]), + 799 => self.port_declaration_item_group_1(&children[0]), + 800 => self.port_type_concrete(&children[0], &children[1], &children[2]), + 801 => self.port_type_concrete_opt_0(&children[0]), + 802 => self.port_type_concrete_opt_1(), + 803 => self.port_type_abstract(&children[0], &children[1], &children[2]), + 804 => self.port_type_abstract_opt0_0(&children[0]), + 805 => self.port_type_abstract_opt0_1(), + 806 => self.port_type_abstract_opt_0(&children[0]), + 807 => self.port_type_abstract_opt_1(), + 808 => self.direction_0(&children[0]), + 809 => self.direction_1(&children[0]), + 810 => self.direction_2(&children[0]), + 811 => self.direction_3(&children[0]), + 812 => self.direction_4(&children[0]), + 813 => self.direction_5(&children[0]), + 814 => self.function_declaration( &children[0], &children[1], &children[2], @@ -36182,25 +36804,25 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 807 => self.function_declaration_list_0(&children[0], &children[1]), - 808 => self.function_declaration_list_1(), - 809 => self.function_declaration_opt1_0(&children[0], &children[1]), - 810 => self.function_declaration_opt1_1(), - 811 => self.function_declaration_opt0_0(&children[0]), - 812 => self.function_declaration_opt0_1(), - 813 => self.function_declaration_opt_0(&children[0]), - 814 => self.function_declaration_opt_1(), - 815 => self.function_item_0(&children[0]), - 816 => self.function_item_1(&children[0]), - 817 => self.import_declaration(&children[0], &children[1], &children[2], &children[3]), - 818 => self.import_declaration_opt_0(&children[0], &children[1]), - 819 => self.import_declaration_opt_1(), - 820 => self.export_declaration(&children[0], &children[1], &children[2]), - 821 => self.export_declaration_group_0(&children[0]), - 822 => self.export_declaration_group_1(&children[0], &children[1]), - 823 => self.export_declaration_opt_0(&children[0], &children[1]), - 824 => self.export_declaration_opt_1(), - 825 => self.unsafe_block( + 815 => self.function_declaration_list_0(&children[0], &children[1]), + 816 => self.function_declaration_list_1(), + 817 => self.function_declaration_opt1_0(&children[0], &children[1]), + 818 => self.function_declaration_opt1_1(), + 819 => self.function_declaration_opt0_0(&children[0]), + 820 => self.function_declaration_opt0_1(), + 821 => self.function_declaration_opt_0(&children[0]), + 822 => self.function_declaration_opt_1(), + 823 => self.function_item_0(&children[0]), + 824 => self.function_item_1(&children[0]), + 825 => self.import_declaration(&children[0], &children[1], &children[2], &children[3]), + 826 => self.import_declaration_opt_0(&children[0], &children[1]), + 827 => self.import_declaration_opt_1(), + 828 => self.export_declaration(&children[0], &children[1], &children[2]), + 829 => self.export_declaration_group_0(&children[0]), + 830 => self.export_declaration_group_1(&children[0], &children[1]), + 831 => self.export_declaration_opt_0(&children[0], &children[1]), + 832 => self.export_declaration_opt_1(), + 833 => self.unsafe_block( &children[0], &children[1], &children[2], @@ -36209,9 +36831,9 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 826 => self.unsafe_block_list_0(&children[0], &children[1]), - 827 => self.unsafe_block_list_1(), - 828 => self.module_declaration( + 834 => self.unsafe_block_list_0(&children[0], &children[1]), + 835 => self.unsafe_block_list_1(), + 836 => self.module_declaration( &children[0], &children[1], &children[2], @@ -36221,35 +36843,38 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], &children[8], + &children[9], ), - 829 => self.module_declaration_list_0(&children[0], &children[1]), - 830 => self.module_declaration_list_1(), - 831 => self.module_declaration_opt2_0(&children[0]), - 832 => self.module_declaration_opt2_1(), - 833 => self.module_declaration_opt1_0(&children[0]), - 834 => self.module_declaration_opt1_1(), - 835 => self.module_declaration_opt0_0(&children[0]), - 836 => self.module_declaration_opt0_1(), - 837 => self.module_declaration_opt_0(&children[0]), - 838 => self.module_declaration_opt_1(), - 839 => self.module_if_declaration( + 837 => self.module_declaration_list_0(&children[0], &children[1]), + 838 => self.module_declaration_list_1(), + 839 => self.module_declaration_opt3_0(&children[0]), + 840 => self.module_declaration_opt3_1(), + 841 => self.module_declaration_opt2_0(&children[0]), + 842 => self.module_declaration_opt2_1(), + 843 => self.module_declaration_opt1_0(&children[0], &children[1]), + 844 => self.module_declaration_opt1_1(), + 845 => self.module_declaration_opt0_0(&children[0]), + 846 => self.module_declaration_opt0_1(), + 847 => self.module_declaration_opt_0(&children[0]), + 848 => self.module_declaration_opt_1(), + 849 => self.module_if_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 840 => self.module_if_declaration_list_0( + 850 => self.module_if_declaration_list_0( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 841 => self.module_if_declaration_list_1(), - 842 => self.module_if_declaration_opt_0(&children[0], &children[1]), - 843 => self.module_if_declaration_opt_1(), - 844 => self.module_for_declaration( + 851 => self.module_if_declaration_list_1(), + 852 => self.module_if_declaration_opt_0(&children[0], &children[1]), + 853 => self.module_if_declaration_opt_1(), + 854 => self.module_for_declaration( &children[0], &children[1], &children[2], @@ -36257,53 +36882,53 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 845 => self.module_for_declaration_opt_0(&children[0], &children[1], &children[2]), - 846 => self.module_for_declaration_opt_1(), - 847 => self.module_named_block( + 855 => self.module_for_declaration_opt_0(&children[0], &children[1], &children[2]), + 856 => self.module_for_declaration_opt_1(), + 857 => self.module_named_block( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 848 => self.module_named_block_list_0(&children[0], &children[1]), - 849 => self.module_named_block_list_1(), - 850 => self.module_optional_named_block( + 858 => self.module_named_block_list_0(&children[0], &children[1]), + 859 => self.module_named_block_list_1(), + 860 => self.module_optional_named_block( &children[0], &children[1], &children[2], &children[3], ), - 851 => self.module_optional_named_block_list_0(&children[0], &children[1]), - 852 => self.module_optional_named_block_list_1(), - 853 => self.module_optional_named_block_opt_0(&children[0], &children[1]), - 854 => self.module_optional_named_block_opt_1(), - 855 => self.module_group(&children[0], &children[1]), - 856 => self.module_group_group_0(&children[0], &children[1], &children[2]), - 857 => self.module_group_group_list_0(&children[0], &children[1]), - 858 => self.module_group_group_list_1(), - 859 => self.module_group_group_1(&children[0]), - 860 => self.module_group_list_0(&children[0], &children[1]), - 861 => self.module_group_list_1(), - 862 => self.module_item_0(&children[0]), - 863 => self.module_item_1(&children[0]), - 864 => self.module_item_2(&children[0]), - 865 => self.module_item_3(&children[0]), - 866 => self.module_item_4(&children[0]), - 867 => self.module_item_5(&children[0]), - 868 => self.module_item_6(&children[0]), - 869 => self.module_item_7(&children[0]), - 870 => self.module_item_8(&children[0]), - 871 => self.module_item_9(&children[0]), - 872 => self.module_item_10(&children[0]), - 873 => self.module_item_11(&children[0]), - 874 => self.module_item_12(&children[0]), - 875 => self.module_item_13(&children[0]), - 876 => self.module_item_14(&children[0]), - 877 => self.module_item_15(&children[0]), - 878 => self.module_item_16(&children[0]), - 879 => self.module_item_17(&children[0]), - 880 => self.interface_declaration( + 861 => self.module_optional_named_block_list_0(&children[0], &children[1]), + 862 => self.module_optional_named_block_list_1(), + 863 => self.module_optional_named_block_opt_0(&children[0], &children[1]), + 864 => self.module_optional_named_block_opt_1(), + 865 => self.module_group(&children[0], &children[1]), + 866 => self.module_group_group_0(&children[0], &children[1], &children[2]), + 867 => self.module_group_group_list_0(&children[0], &children[1]), + 868 => self.module_group_group_list_1(), + 869 => self.module_group_group_1(&children[0]), + 870 => self.module_group_list_0(&children[0], &children[1]), + 871 => self.module_group_list_1(), + 872 => self.module_item_0(&children[0]), + 873 => self.module_item_1(&children[0]), + 874 => self.module_item_2(&children[0]), + 875 => self.module_item_3(&children[0]), + 876 => self.module_item_4(&children[0]), + 877 => self.module_item_5(&children[0]), + 878 => self.module_item_6(&children[0]), + 879 => self.module_item_7(&children[0]), + 880 => self.module_item_8(&children[0]), + 881 => self.module_item_9(&children[0]), + 882 => self.module_item_10(&children[0]), + 883 => self.module_item_11(&children[0]), + 884 => self.module_item_12(&children[0]), + 885 => self.module_item_13(&children[0]), + 886 => self.module_item_14(&children[0]), + 887 => self.module_item_15(&children[0]), + 888 => self.module_item_16(&children[0]), + 889 => self.module_item_17(&children[0]), + 890 => self.interface_declaration( &children[0], &children[1], &children[2], @@ -36313,32 +36938,32 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 881 => self.interface_declaration_list_0(&children[0], &children[1]), - 882 => self.interface_declaration_list_1(), - 883 => self.interface_declaration_opt1_0(&children[0]), - 884 => self.interface_declaration_opt1_1(), - 885 => self.interface_declaration_opt0_0(&children[0]), - 886 => self.interface_declaration_opt0_1(), - 887 => self.interface_declaration_opt_0(&children[0]), - 888 => self.interface_declaration_opt_1(), - 889 => self.interface_if_declaration( + 891 => self.interface_declaration_list_0(&children[0], &children[1]), + 892 => self.interface_declaration_list_1(), + 893 => self.interface_declaration_opt1_0(&children[0]), + 894 => self.interface_declaration_opt1_1(), + 895 => self.interface_declaration_opt0_0(&children[0]), + 896 => self.interface_declaration_opt0_1(), + 897 => self.interface_declaration_opt_0(&children[0]), + 898 => self.interface_declaration_opt_1(), + 899 => self.interface_if_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 890 => self.interface_if_declaration_list_0( + 900 => self.interface_if_declaration_list_0( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 891 => self.interface_if_declaration_list_1(), - 892 => self.interface_if_declaration_opt_0(&children[0], &children[1]), - 893 => self.interface_if_declaration_opt_1(), - 894 => self.interface_for_declaration( + 901 => self.interface_if_declaration_list_1(), + 902 => self.interface_if_declaration_opt_0(&children[0], &children[1]), + 903 => self.interface_if_declaration_opt_1(), + 904 => self.interface_for_declaration( &children[0], &children[1], &children[2], @@ -36346,49 +36971,81 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 895 => self.interface_for_declaration_opt_0(&children[0], &children[1], &children[2]), - 896 => self.interface_for_declaration_opt_1(), - 897 => self.interface_named_block( + 905 => self.interface_for_declaration_opt_0(&children[0], &children[1], &children[2]), + 906 => self.interface_for_declaration_opt_1(), + 907 => self.interface_named_block( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 898 => self.interface_named_block_list_0(&children[0], &children[1]), - 899 => self.interface_named_block_list_1(), - 900 => self.interface_optional_named_block( + 908 => self.interface_named_block_list_0(&children[0], &children[1]), + 909 => self.interface_named_block_list_1(), + 910 => self.interface_optional_named_block( &children[0], &children[1], &children[2], &children[3], ), - 901 => self.interface_optional_named_block_list_0(&children[0], &children[1]), - 902 => self.interface_optional_named_block_list_1(), - 903 => self.interface_optional_named_block_opt_0(&children[0], &children[1]), - 904 => self.interface_optional_named_block_opt_1(), - 905 => self.interface_group(&children[0], &children[1]), - 906 => self.interface_group_group_0(&children[0], &children[1], &children[2]), - 907 => self.interface_group_group_list_0(&children[0], &children[1]), - 908 => self.interface_group_group_list_1(), - 909 => self.interface_group_group_1(&children[0]), - 910 => self.interface_group_list_0(&children[0], &children[1]), - 911 => self.interface_group_list_1(), - 912 => self.interface_item_0(&children[0]), - 913 => self.interface_item_1(&children[0]), - 914 => self.interface_item_2(&children[0]), - 915 => self.interface_item_3(&children[0]), - 916 => self.interface_item_4(&children[0]), - 917 => self.interface_item_5(&children[0]), - 918 => self.interface_item_6(&children[0]), - 919 => self.interface_item_7(&children[0]), - 920 => self.interface_item_8(&children[0]), - 921 => self.interface_item_9(&children[0]), - 922 => self.interface_item_10(&children[0]), - 923 => self.interface_item_11(&children[0]), - 924 => self.interface_item_12(&children[0]), - 925 => self.interface_item_13(&children[0]), - 926 => self.package_declaration( + 911 => self.interface_optional_named_block_list_0(&children[0], &children[1]), + 912 => self.interface_optional_named_block_list_1(), + 913 => self.interface_optional_named_block_opt_0(&children[0], &children[1]), + 914 => self.interface_optional_named_block_opt_1(), + 915 => self.interface_group(&children[0], &children[1]), + 916 => self.interface_group_group_0(&children[0], &children[1], &children[2]), + 917 => self.interface_group_group_list_0(&children[0], &children[1]), + 918 => self.interface_group_group_list_1(), + 919 => self.interface_group_group_1(&children[0]), + 920 => self.interface_group_list_0(&children[0], &children[1]), + 921 => self.interface_group_list_1(), + 922 => self.interface_item_0(&children[0]), + 923 => self.interface_item_1(&children[0]), + 924 => self.interface_item_2(&children[0]), + 925 => self.interface_item_3(&children[0]), + 926 => self.interface_item_4(&children[0]), + 927 => self.interface_item_5(&children[0]), + 928 => self.interface_item_6(&children[0]), + 929 => self.interface_item_7(&children[0]), + 930 => self.interface_item_8(&children[0]), + 931 => self.interface_item_9(&children[0]), + 932 => self.interface_item_10(&children[0]), + 933 => self.interface_item_11(&children[0]), + 934 => self.interface_item_12(&children[0]), + 935 => self.interface_item_13(&children[0]), + 936 => self.package_declaration( + &children[0], + &children[1], + &children[2], + &children[3], + &children[4], + &children[5], + &children[6], + ), + 937 => self.package_declaration_list_0(&children[0], &children[1]), + 938 => self.package_declaration_list_1(), + 939 => self.package_declaration_opt0_0(&children[0]), + 940 => self.package_declaration_opt0_1(), + 941 => self.package_declaration_opt_0(&children[0]), + 942 => self.package_declaration_opt_1(), + 943 => self.package_group(&children[0], &children[1]), + 944 => self.package_group_group_0(&children[0], &children[1], &children[2]), + 945 => self.package_group_group_list_0(&children[0], &children[1]), + 946 => self.package_group_group_list_1(), + 947 => self.package_group_group_1(&children[0]), + 948 => self.package_group_list_0(&children[0], &children[1]), + 949 => self.package_group_list_1(), + 950 => self.package_item_0(&children[0]), + 951 => self.package_item_1(&children[0]), + 952 => self.package_item_2(&children[0]), + 953 => self.package_item_3(&children[0]), + 954 => self.package_item_4(&children[0]), + 955 => self.package_item_5(&children[0]), + 956 => self.package_item_6(&children[0]), + 957 => self.package_item_7(&children[0]), + 958 => self.package_item_8(&children[0]), + 959 => self.package_item_9(&children[0]), + 960 => self.proto_module_declaration( &children[0], &children[1], &children[2], @@ -36397,30 +37054,13 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 927 => self.package_declaration_list_0(&children[0], &children[1]), - 928 => self.package_declaration_list_1(), - 929 => self.package_declaration_opt0_0(&children[0]), - 930 => self.package_declaration_opt0_1(), - 931 => self.package_declaration_opt_0(&children[0]), - 932 => self.package_declaration_opt_1(), - 933 => self.package_group(&children[0], &children[1]), - 934 => self.package_group_group_0(&children[0], &children[1], &children[2]), - 935 => self.package_group_group_list_0(&children[0], &children[1]), - 936 => self.package_group_group_list_1(), - 937 => self.package_group_group_1(&children[0]), - 938 => self.package_group_list_0(&children[0], &children[1]), - 939 => self.package_group_list_1(), - 940 => self.package_item_0(&children[0]), - 941 => self.package_item_1(&children[0]), - 942 => self.package_item_2(&children[0]), - 943 => self.package_item_3(&children[0]), - 944 => self.package_item_4(&children[0]), - 945 => self.package_item_5(&children[0]), - 946 => self.package_item_6(&children[0]), - 947 => self.package_item_7(&children[0]), - 948 => self.package_item_8(&children[0]), - 949 => self.package_item_9(&children[0]), - 950 => self.embed_declaration( + 961 => self.proto_module_declaration_opt1_0(&children[0]), + 962 => self.proto_module_declaration_opt1_1(), + 963 => self.proto_module_declaration_opt0_0(&children[0]), + 964 => self.proto_module_declaration_opt0_1(), + 965 => self.proto_module_declaration_opt_0(&children[0]), + 966 => self.proto_module_declaration_opt_1(), + 967 => self.embed_declaration( &children[0], &children[1], &children[2], @@ -36428,8 +37068,8 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 951 => self.embed_content(&children[0]), - 952 => self.embed_content_token( + 968 => self.embed_content(&children[0]), + 969 => self.embed_content_token( &children[0], &children[1], &children[2], @@ -36439,13 +37079,13 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 953 => self.embed_content_token_list_0(&children[0], &children[1]), - 954 => self.embed_content_token_list_1(), - 955 => self.embed_item_0(&children[0], &children[1], &children[2]), - 956 => self.embed_item_list_0(&children[0], &children[1]), - 957 => self.embed_item_list_1(), - 958 => self.embed_item_1(&children[0]), - 959 => self.include_declaration( + 970 => self.embed_content_token_list_0(&children[0], &children[1]), + 971 => self.embed_content_token_list_1(), + 972 => self.embed_item_0(&children[0], &children[1], &children[2]), + 973 => self.embed_item_list_0(&children[0], &children[1]), + 974 => self.embed_item_list_1(), + 975 => self.embed_item_1(&children[0]), + 976 => self.include_declaration( &children[0], &children[1], &children[2], @@ -36454,22 +37094,23 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 960 => self.description_group(&children[0], &children[1]), - 961 => self.description_group_group_0(&children[0], &children[1], &children[2]), - 962 => self.description_group_group_list_0(&children[0], &children[1]), - 963 => self.description_group_group_list_1(), - 964 => self.description_group_group_1(&children[0]), - 965 => self.description_group_list_0(&children[0], &children[1]), - 966 => self.description_group_list_1(), - 967 => self.description_item_0(&children[0]), - 968 => self.description_item_1(&children[0]), - 969 => self.description_item_2(&children[0]), - 970 => self.description_item_3(&children[0]), - 971 => self.description_item_4(&children[0]), - 972 => self.description_item_5(&children[0]), - 973 => self.veryl(&children[0], &children[1]), - 974 => self.veryl_list_0(&children[0], &children[1]), - 975 => self.veryl_list_1(), + 977 => self.description_group(&children[0], &children[1]), + 978 => self.description_group_group_0(&children[0], &children[1], &children[2]), + 979 => self.description_group_group_list_0(&children[0], &children[1]), + 980 => self.description_group_group_list_1(), + 981 => self.description_group_group_1(&children[0]), + 982 => self.description_group_list_0(&children[0], &children[1]), + 983 => self.description_group_list_1(), + 984 => self.description_item_0(&children[0]), + 985 => self.description_item_1(&children[0]), + 986 => self.description_item_2(&children[0]), + 987 => self.description_item_3(&children[0]), + 988 => self.description_item_4(&children[0]), + 989 => self.description_item_5(&children[0]), + 990 => self.description_item_6(&children[0]), + 991 => self.veryl(&children[0], &children[1]), + 992 => self.veryl_list_0(&children[0], &children[1]), + 993 => 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 050e5557..748cb320 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; 118] = &[ +pub const TERMINALS: &[&str; 120] = &[ /* 0 */ UNMATCHABLE_TOKEN, /* 1 */ UNMATCHABLE_TOKEN, /* 2 */ UNMATCHABLE_TOKEN, @@ -78,69 +78,71 @@ pub const TERMINALS: &[&str; 118] = &[ /* 55 */ r"(?-u:\b)clock(?-u:\b)", /* 56 */ r"(?-u:\b)clock_posedge(?-u:\b)", /* 57 */ r"(?-u:\b)clock_negedge(?-u:\b)", - /* 58 */ r"(?-u:\b)default(?-u:\b)", - /* 59 */ r"(?-u:\b)else(?-u:\b)", - /* 60 */ r"(?-u:\b)embed(?-u:\b)", - /* 61 */ r"(?-u:\b)enum(?-u:\b)", - /* 62 */ r"(?-u:\b)export(?-u:\b)", - /* 63 */ r"(?-u:\b)f32(?-u:\b)", - /* 64 */ r"(?-u:\b)f64(?-u:\b)", - /* 65 */ r"(?-u:\b)final(?-u:\b)", - /* 66 */ r"(?-u:\b)for(?-u:\b)", - /* 67 */ r"(?-u:\b)function(?-u:\b)", - /* 68 */ r"(?-u:\b)i32(?-u:\b)", - /* 69 */ r"(?-u:\b)i64(?-u:\b)", - /* 70 */ r"(?-u:\b)if_reset(?-u:\b)", - /* 71 */ r"(?-u:\b)if(?-u:\b)", - /* 72 */ r"(?-u:\b)import(?-u:\b)", - /* 73 */ r"(?-u:\b)include(?-u:\b)", - /* 74 */ r"(?-u:\b)initial(?-u:\b)", - /* 75 */ r"(?-u:\b)inout(?-u:\b)", - /* 76 */ r"(?-u:\b)input(?-u:\b)", - /* 77 */ r"(?-u:\b)inside(?-u:\b)", - /* 78 */ r"(?-u:\b)inst(?-u:\b)", - /* 79 */ r"(?-u:\b)interface(?-u:\b)", - /* 80 */ r"(?-u:\b)in(?-u:\b)", - /* 81 */ r"(?-u:\b)let(?-u:\b)", - /* 82 */ r"(?-u:\b)local(?-u:\b)", - /* 83 */ r"(?-u:\b)logic(?-u:\b)", - /* 84 */ r"(?-u:\b)lsb(?-u:\b)", - /* 85 */ r"(?-u:\b)modport(?-u:\b)", - /* 86 */ r"(?-u:\b)module(?-u:\b)", - /* 87 */ r"(?-u:\b)msb(?-u:\b)", - /* 88 */ r"(?-u:\b)output(?-u:\b)", - /* 89 */ r"(?-u:\b)outside(?-u:\b)", - /* 90 */ r"(?-u:\b)package(?-u:\b)", - /* 91 */ r"(?-u:\b)param(?-u:\b)", - /* 92 */ r"(?-u:\b)pub(?-u:\b)", - /* 93 */ r"(?-u:\b)ref(?-u:\b)", - /* 94 */ r"(?-u:\b)repeat(?-u:\b)", - /* 95 */ r"(?-u:\b)reset(?-u:\b)", - /* 96 */ r"(?-u:\b)reset_async_high(?-u:\b)", - /* 97 */ r"(?-u:\b)reset_async_low(?-u:\b)", - /* 98 */ r"(?-u:\b)reset_sync_high(?-u:\b)", - /* 99 */ r"(?-u:\b)reset_sync_low(?-u:\b)", - /* 100 */ r"(?-u:\b)return(?-u:\b)", - /* 101 */ r"(?-u:\b)break(?-u:\b)", - /* 102 */ r"(?-u:\b)signed(?-u:\b)", - /* 103 */ r"(?-u:\b)step(?-u:\b)", - /* 104 */ r"(?-u:\b)string(?-u:\b)", - /* 105 */ r"(?-u:\b)struct(?-u:\b)", - /* 106 */ r"(?-u:\b)switch(?-u:\b)", - /* 107 */ r"(?-u:\b)tri(?-u:\b)", - /* 108 */ r"(?-u:\b)type(?-u:\b)", - /* 109 */ r"(?-u:\b)u32(?-u:\b)", - /* 110 */ r"(?-u:\b)u64(?-u:\b)", - /* 111 */ r"(?-u:\b)union(?-u:\b)", - /* 112 */ r"(?-u:\b)unsafe(?-u:\b)", - /* 113 */ r"(?-u:\b)var(?-u:\b)", - /* 114 */ r"\$[a-zA-Z_][0-9a-zA-Z_$]*", - /* 115 */ r"(?:r#)?[a-zA-Z_][0-9a-zA-Z_$]*", - /* 116 */ r"[^{}]*", - /* 117 */ ERROR_TOKEN, + /* 58 */ r"(?-u:\b)const(?-u:\b)", + /* 59 */ r"(?-u:\b)default(?-u:\b)", + /* 60 */ r"(?-u:\b)else(?-u:\b)", + /* 61 */ r"(?-u:\b)embed(?-u:\b)", + /* 62 */ r"(?-u:\b)enum(?-u:\b)", + /* 63 */ r"(?-u:\b)export(?-u:\b)", + /* 64 */ r"(?-u:\b)f32(?-u:\b)", + /* 65 */ r"(?-u:\b)f64(?-u:\b)", + /* 66 */ r"(?-u:\b)final(?-u:\b)", + /* 67 */ r"(?-u:\b)for(?-u:\b)", + /* 68 */ r"(?-u:\b)function(?-u:\b)", + /* 69 */ r"(?-u:\b)i32(?-u:\b)", + /* 70 */ r"(?-u:\b)i64(?-u:\b)", + /* 71 */ r"(?-u:\b)if_reset(?-u:\b)", + /* 72 */ r"(?-u:\b)if(?-u:\b)", + /* 73 */ r"(?-u:\b)import(?-u:\b)", + /* 74 */ r"(?-u:\b)include(?-u:\b)", + /* 75 */ r"(?-u:\b)initial(?-u:\b)", + /* 76 */ r"(?-u:\b)inout(?-u:\b)", + /* 77 */ r"(?-u:\b)input(?-u:\b)", + /* 78 */ r"(?-u:\b)inside(?-u:\b)", + /* 79 */ r"(?-u:\b)inst(?-u:\b)", + /* 80 */ r"(?-u:\b)interface(?-u:\b)", + /* 81 */ r"(?-u:\b)in(?-u:\b)", + /* 82 */ r"(?-u:\b)let(?-u:\b)", + /* 83 */ r"(?-u:\b)local(?-u:\b)", + /* 84 */ r"(?-u:\b)logic(?-u:\b)", + /* 85 */ r"(?-u:\b)lsb(?-u:\b)", + /* 86 */ r"(?-u:\b)modport(?-u:\b)", + /* 87 */ r"(?-u:\b)module(?-u:\b)", + /* 88 */ r"(?-u:\b)msb(?-u:\b)", + /* 89 */ r"(?-u:\b)output(?-u:\b)", + /* 90 */ r"(?-u:\b)outside(?-u:\b)", + /* 91 */ r"(?-u:\b)package(?-u:\b)", + /* 92 */ r"(?-u:\b)param(?-u:\b)", + /* 93 */ r"(?-u:\b)proto(?-u:\b)", + /* 94 */ r"(?-u:\b)pub(?-u:\b)", + /* 95 */ r"(?-u:\b)ref(?-u:\b)", + /* 96 */ r"(?-u:\b)repeat(?-u:\b)", + /* 97 */ r"(?-u:\b)reset(?-u:\b)", + /* 98 */ r"(?-u:\b)reset_async_high(?-u:\b)", + /* 99 */ r"(?-u:\b)reset_async_low(?-u:\b)", + /* 100 */ r"(?-u:\b)reset_sync_high(?-u:\b)", + /* 101 */ r"(?-u:\b)reset_sync_low(?-u:\b)", + /* 102 */ r"(?-u:\b)return(?-u:\b)", + /* 103 */ r"(?-u:\b)break(?-u:\b)", + /* 104 */ r"(?-u:\b)signed(?-u:\b)", + /* 105 */ r"(?-u:\b)step(?-u:\b)", + /* 106 */ r"(?-u:\b)string(?-u:\b)", + /* 107 */ r"(?-u:\b)struct(?-u:\b)", + /* 108 */ r"(?-u:\b)switch(?-u:\b)", + /* 109 */ r"(?-u:\b)tri(?-u:\b)", + /* 110 */ r"(?-u:\b)type(?-u:\b)", + /* 111 */ r"(?-u:\b)u32(?-u:\b)", + /* 112 */ r"(?-u:\b)u64(?-u:\b)", + /* 113 */ r"(?-u:\b)union(?-u:\b)", + /* 114 */ r"(?-u:\b)unsafe(?-u:\b)", + /* 115 */ r"(?-u:\b)var(?-u:\b)", + /* 116 */ r"\$[a-zA-Z_][0-9a-zA-Z_$]*", + /* 117 */ r"(?:r#)?[a-zA-Z_][0-9a-zA-Z_$]*", + /* 118 */ r"[^{}]*", + /* 119 */ ERROR_TOKEN, ]; -pub const TERMINAL_NAMES: &[&str; 118] = &[ +pub const TERMINAL_NAMES: &[&str; 120] = &[ /* 0 */ "EndOfInput", /* 1 */ "Newline", /* 2 */ "Whitespace", @@ -199,70 +201,72 @@ pub const TERMINAL_NAMES: &[&str; 118] = &[ /* 55 */ "ClockTerm", /* 56 */ "ClockPosedgeTerm", /* 57 */ "ClockNegedgeTerm", - /* 58 */ "DefaultTerm", - /* 59 */ "ElseTerm", - /* 60 */ "EmbedTerm", - /* 61 */ "EnumTerm", - /* 62 */ "ExportTerm", - /* 63 */ "F32Term", - /* 64 */ "F64Term", - /* 65 */ "FinalTerm", - /* 66 */ "ForTerm", - /* 67 */ "FunctionTerm", - /* 68 */ "I32Term", - /* 69 */ "I64Term", - /* 70 */ "IfResetTerm", - /* 71 */ "IfTerm", - /* 72 */ "ImportTerm", - /* 73 */ "IncludeTerm", - /* 74 */ "InitialTerm", - /* 75 */ "InoutTerm", - /* 76 */ "InputTerm", - /* 77 */ "InsideTerm", - /* 78 */ "InstTerm", - /* 79 */ "InterfaceTerm", - /* 80 */ "InTerm", - /* 81 */ "LetTerm", - /* 82 */ "LocalTerm", - /* 83 */ "LogicTerm", - /* 84 */ "LsbTerm", - /* 85 */ "ModportTerm", - /* 86 */ "ModuleTerm", - /* 87 */ "MsbTerm", - /* 88 */ "OutputTerm", - /* 89 */ "OutsideTerm", - /* 90 */ "PackageTerm", - /* 91 */ "ParamTerm", - /* 92 */ "PubTerm", - /* 93 */ "RefTerm", - /* 94 */ "RepeatTerm", - /* 95 */ "ResetTerm", - /* 96 */ "ResetAsyncHighTerm", - /* 97 */ "ResetAsyncLowTerm", - /* 98 */ "ResetSyncHighTerm", - /* 99 */ "ResetSyncLowTerm", - /* 100 */ "ReturnTerm", - /* 101 */ "BreakTerm", - /* 102 */ "SignedTerm", - /* 103 */ "StepTerm", - /* 104 */ "StringTerm", - /* 105 */ "StructTerm", - /* 106 */ "SwitchTerm", - /* 107 */ "TriTerm", - /* 108 */ "TypeTerm", - /* 109 */ "U32Term", - /* 110 */ "U64Term", - /* 111 */ "UnionTerm", - /* 112 */ "UnsafeTerm", - /* 113 */ "VarTerm", - /* 114 */ "DollarIdentifierTerm", - /* 115 */ "IdentifierTerm", - /* 116 */ "AnyTerm", - /* 117 */ "Error", + /* 58 */ "ConstTerm", + /* 59 */ "DefaultTerm", + /* 60 */ "ElseTerm", + /* 61 */ "EmbedTerm", + /* 62 */ "EnumTerm", + /* 63 */ "ExportTerm", + /* 64 */ "F32Term", + /* 65 */ "F64Term", + /* 66 */ "FinalTerm", + /* 67 */ "ForTerm", + /* 68 */ "FunctionTerm", + /* 69 */ "I32Term", + /* 70 */ "I64Term", + /* 71 */ "IfResetTerm", + /* 72 */ "IfTerm", + /* 73 */ "ImportTerm", + /* 74 */ "IncludeTerm", + /* 75 */ "InitialTerm", + /* 76 */ "InoutTerm", + /* 77 */ "InputTerm", + /* 78 */ "InsideTerm", + /* 79 */ "InstTerm", + /* 80 */ "InterfaceTerm", + /* 81 */ "InTerm", + /* 82 */ "LetTerm", + /* 83 */ "LocalTerm", + /* 84 */ "LogicTerm", + /* 85 */ "LsbTerm", + /* 86 */ "ModportTerm", + /* 87 */ "ModuleTerm", + /* 88 */ "MsbTerm", + /* 89 */ "OutputTerm", + /* 90 */ "OutsideTerm", + /* 91 */ "PackageTerm", + /* 92 */ "ParamTerm", + /* 93 */ "ProtoTerm", + /* 94 */ "PubTerm", + /* 95 */ "RefTerm", + /* 96 */ "RepeatTerm", + /* 97 */ "ResetTerm", + /* 98 */ "ResetAsyncHighTerm", + /* 99 */ "ResetAsyncLowTerm", + /* 100 */ "ResetSyncHighTerm", + /* 101 */ "ResetSyncLowTerm", + /* 102 */ "ReturnTerm", + /* 103 */ "BreakTerm", + /* 104 */ "SignedTerm", + /* 105 */ "StepTerm", + /* 106 */ "StringTerm", + /* 107 */ "StructTerm", + /* 108 */ "SwitchTerm", + /* 109 */ "TriTerm", + /* 110 */ "TypeTerm", + /* 111 */ "U32Term", + /* 112 */ "U64Term", + /* 113 */ "UnionTerm", + /* 114 */ "UnsafeTerm", + /* 115 */ "VarTerm", + /* 116 */ "DollarIdentifierTerm", + /* 117 */ "IdentifierTerm", + /* 118 */ "AnyTerm", + /* 119 */ "Error", ]; /* SCANNER_0: "INITIAL" */ -const SCANNER_0: (&[&str; 5], &[TerminalIndex; 111]) = ( +const SCANNER_0: (&[&str; 5], &[TerminalIndex; 113]) = ( &[ /* 0 */ UNMATCHABLE_TOKEN, /* 1 */ NEW_LINE_TOKEN, @@ -324,64 +328,66 @@ const SCANNER_0: (&[&str; 5], &[TerminalIndex; 111]) = ( 55, /* ClockTerm */ 56, /* ClockPosedgeTerm */ 57, /* ClockNegedgeTerm */ - 58, /* DefaultTerm */ - 59, /* ElseTerm */ - 60, /* EmbedTerm */ - 61, /* EnumTerm */ - 62, /* ExportTerm */ - 63, /* F32Term */ - 64, /* F64Term */ - 65, /* FinalTerm */ - 66, /* ForTerm */ - 67, /* FunctionTerm */ - 68, /* I32Term */ - 69, /* I64Term */ - 70, /* IfResetTerm */ - 71, /* IfTerm */ - 72, /* ImportTerm */ - 73, /* IncludeTerm */ - 74, /* InitialTerm */ - 75, /* InoutTerm */ - 76, /* InputTerm */ - 77, /* InsideTerm */ - 78, /* InstTerm */ - 79, /* InterfaceTerm */ - 80, /* InTerm */ - 81, /* LetTerm */ - 82, /* LocalTerm */ - 83, /* LogicTerm */ - 84, /* LsbTerm */ - 85, /* ModportTerm */ - 86, /* ModuleTerm */ - 87, /* MsbTerm */ - 88, /* OutputTerm */ - 89, /* OutsideTerm */ - 90, /* PackageTerm */ - 91, /* ParamTerm */ - 92, /* PubTerm */ - 93, /* RefTerm */ - 94, /* RepeatTerm */ - 95, /* ResetTerm */ - 96, /* ResetAsyncHighTerm */ - 97, /* ResetAsyncLowTerm */ - 98, /* ResetSyncHighTerm */ - 99, /* ResetSyncLowTerm */ - 100, /* ReturnTerm */ - 101, /* BreakTerm */ - 102, /* SignedTerm */ - 103, /* StepTerm */ - 104, /* StringTerm */ - 105, /* StructTerm */ - 106, /* SwitchTerm */ - 107, /* TriTerm */ - 108, /* TypeTerm */ - 109, /* U32Term */ - 110, /* U64Term */ - 111, /* UnionTerm */ - 112, /* UnsafeTerm */ - 113, /* VarTerm */ - 114, /* DollarIdentifierTerm */ - 115, /* IdentifierTerm */ + 58, /* ConstTerm */ + 59, /* DefaultTerm */ + 60, /* ElseTerm */ + 61, /* EmbedTerm */ + 62, /* EnumTerm */ + 63, /* ExportTerm */ + 64, /* F32Term */ + 65, /* F64Term */ + 66, /* FinalTerm */ + 67, /* ForTerm */ + 68, /* FunctionTerm */ + 69, /* I32Term */ + 70, /* I64Term */ + 71, /* IfResetTerm */ + 72, /* IfTerm */ + 73, /* ImportTerm */ + 74, /* IncludeTerm */ + 75, /* InitialTerm */ + 76, /* InoutTerm */ + 77, /* InputTerm */ + 78, /* InsideTerm */ + 79, /* InstTerm */ + 80, /* InterfaceTerm */ + 81, /* InTerm */ + 82, /* LetTerm */ + 83, /* LocalTerm */ + 84, /* LogicTerm */ + 85, /* LsbTerm */ + 86, /* ModportTerm */ + 87, /* ModuleTerm */ + 88, /* MsbTerm */ + 89, /* OutputTerm */ + 90, /* OutsideTerm */ + 91, /* PackageTerm */ + 92, /* ParamTerm */ + 93, /* ProtoTerm */ + 94, /* PubTerm */ + 95, /* RefTerm */ + 96, /* RepeatTerm */ + 97, /* ResetTerm */ + 98, /* ResetAsyncHighTerm */ + 99, /* ResetAsyncLowTerm */ + 100, /* ResetSyncHighTerm */ + 101, /* ResetSyncLowTerm */ + 102, /* ReturnTerm */ + 103, /* BreakTerm */ + 104, /* SignedTerm */ + 105, /* StepTerm */ + 106, /* StringTerm */ + 107, /* StructTerm */ + 108, /* SwitchTerm */ + 109, /* TriTerm */ + 110, /* TypeTerm */ + 111, /* U32Term */ + 112, /* U64Term */ + 113, /* UnionTerm */ + 114, /* UnsafeTerm */ + 115, /* VarTerm */ + 116, /* DollarIdentifierTerm */ + 117, /* IdentifierTerm */ ], ); @@ -397,12 +403,12 @@ const SCANNER_1: (&[&str; 5], &[TerminalIndex; 3]) = ( &[ 40, /* LBraceTerm */ 44, /* RBraceTerm */ - 116, /* AnyTerm */ + 118, /* AnyTerm */ ], ); /* SCANNER_2: "Generic" */ -const SCANNER_2: (&[&str; 5], &[TerminalIndex; 95]) = ( +const SCANNER_2: (&[&str; 5], &[TerminalIndex; 97]) = ( &[ /* 0 */ UNMATCHABLE_TOKEN, /* 1 */ NEW_LINE_TOKEN, @@ -448,70 +454,72 @@ const SCANNER_2: (&[&str; 5], &[TerminalIndex; 95]) = ( 55, /* ClockTerm */ 56, /* ClockPosedgeTerm */ 57, /* ClockNegedgeTerm */ - 58, /* DefaultTerm */ - 59, /* ElseTerm */ - 60, /* EmbedTerm */ - 61, /* EnumTerm */ - 62, /* ExportTerm */ - 63, /* F32Term */ - 64, /* F64Term */ - 65, /* FinalTerm */ - 66, /* ForTerm */ - 67, /* FunctionTerm */ - 68, /* I32Term */ - 69, /* I64Term */ - 70, /* IfResetTerm */ - 71, /* IfTerm */ - 72, /* ImportTerm */ - 73, /* IncludeTerm */ - 74, /* InitialTerm */ - 75, /* InoutTerm */ - 76, /* InputTerm */ - 77, /* InsideTerm */ - 78, /* InstTerm */ - 79, /* InterfaceTerm */ - 80, /* InTerm */ - 81, /* LetTerm */ - 82, /* LocalTerm */ - 83, /* LogicTerm */ - 84, /* LsbTerm */ - 85, /* ModportTerm */ - 86, /* ModuleTerm */ - 87, /* MsbTerm */ - 88, /* OutputTerm */ - 89, /* OutsideTerm */ - 90, /* PackageTerm */ - 91, /* ParamTerm */ - 92, /* PubTerm */ - 93, /* RefTerm */ - 94, /* RepeatTerm */ - 95, /* ResetTerm */ - 96, /* ResetAsyncHighTerm */ - 97, /* ResetAsyncLowTerm */ - 98, /* ResetSyncHighTerm */ - 99, /* ResetSyncLowTerm */ - 100, /* ReturnTerm */ - 101, /* BreakTerm */ - 102, /* SignedTerm */ - 103, /* StepTerm */ - 104, /* StringTerm */ - 105, /* StructTerm */ - 106, /* SwitchTerm */ - 107, /* TriTerm */ - 108, /* TypeTerm */ - 109, /* U32Term */ - 110, /* U64Term */ - 111, /* UnionTerm */ - 112, /* UnsafeTerm */ - 113, /* VarTerm */ - 114, /* DollarIdentifierTerm */ - 115, /* IdentifierTerm */ + 58, /* ConstTerm */ + 59, /* DefaultTerm */ + 60, /* ElseTerm */ + 61, /* EmbedTerm */ + 62, /* EnumTerm */ + 63, /* ExportTerm */ + 64, /* F32Term */ + 65, /* F64Term */ + 66, /* FinalTerm */ + 67, /* ForTerm */ + 68, /* FunctionTerm */ + 69, /* I32Term */ + 70, /* I64Term */ + 71, /* IfResetTerm */ + 72, /* IfTerm */ + 73, /* ImportTerm */ + 74, /* IncludeTerm */ + 75, /* InitialTerm */ + 76, /* InoutTerm */ + 77, /* InputTerm */ + 78, /* InsideTerm */ + 79, /* InstTerm */ + 80, /* InterfaceTerm */ + 81, /* InTerm */ + 82, /* LetTerm */ + 83, /* LocalTerm */ + 84, /* LogicTerm */ + 85, /* LsbTerm */ + 86, /* ModportTerm */ + 87, /* ModuleTerm */ + 88, /* MsbTerm */ + 89, /* OutputTerm */ + 90, /* OutsideTerm */ + 91, /* PackageTerm */ + 92, /* ParamTerm */ + 93, /* ProtoTerm */ + 94, /* PubTerm */ + 95, /* RefTerm */ + 96, /* RepeatTerm */ + 97, /* ResetTerm */ + 98, /* ResetAsyncHighTerm */ + 99, /* ResetAsyncLowTerm */ + 100, /* ResetSyncHighTerm */ + 101, /* ResetSyncLowTerm */ + 102, /* ReturnTerm */ + 103, /* BreakTerm */ + 104, /* SignedTerm */ + 105, /* StepTerm */ + 106, /* StringTerm */ + 107, /* StructTerm */ + 108, /* SwitchTerm */ + 109, /* TriTerm */ + 110, /* TypeTerm */ + 111, /* U32Term */ + 112, /* U64Term */ + 113, /* UnionTerm */ + 114, /* UnsafeTerm */ + 115, /* VarTerm */ + 116, /* DollarIdentifierTerm */ + 117, /* IdentifierTerm */ ], ); const MAX_K: usize = 3; -pub const NON_TERMINALS: &[&str; 671] = &[ +pub const NON_TERMINALS: &[&str; 682] = &[ /* 0 */ "AllBit", /* 1 */ "AllBitTerm", /* 2 */ "AllBitToken", @@ -624,571 +632,582 @@ pub const NON_TERMINALS: &[&str; 671] = &[ /* 109 */ "ConcatenationList", /* 110 */ "ConcatenationListList", /* 111 */ "ConcatenationListOpt", - /* 112 */ "Defaul", - /* 113 */ "DefaultTerm", - /* 114 */ "DefaultToken", - /* 115 */ "DescriptionGroup", - /* 116 */ "DescriptionGroupGroup", - /* 117 */ "DescriptionGroupGroupList", - /* 118 */ "DescriptionGroupList", - /* 119 */ "DescriptionItem", - /* 120 */ "Direction", - /* 121 */ "DollarIdentifier", - /* 122 */ "DollarIdentifierTerm", - /* 123 */ "DollarIdentifierToken", - /* 124 */ "Dot", - /* 125 */ "DotDot", - /* 126 */ "DotDotEqu", - /* 127 */ "DotDotEquTerm", - /* 128 */ "DotDotEquToken", - /* 129 */ "DotDotTerm", - /* 130 */ "DotDotToken", - /* 131 */ "DotTerm", - /* 132 */ "DotToken", - /* 133 */ "Else", - /* 134 */ "ElseTerm", - /* 135 */ "ElseToken", - /* 136 */ "Embed", - /* 137 */ "EmbedContent", - /* 138 */ "EmbedContentToken", - /* 139 */ "EmbedContentTokenList", - /* 140 */ "EmbedDeclaration", - /* 141 */ "EmbedItem", - /* 142 */ "EmbedItemList", - /* 143 */ "EmbedTerm", - /* 144 */ "EmbedToken", - /* 145 */ "Enum", - /* 146 */ "EnumDeclaration", - /* 147 */ "EnumDeclarationOpt", - /* 148 */ "EnumGroup", - /* 149 */ "EnumGroupGroup", - /* 150 */ "EnumGroupList", - /* 151 */ "EnumItem", - /* 152 */ "EnumItemOpt", - /* 153 */ "EnumList", - /* 154 */ "EnumListList", - /* 155 */ "EnumListOpt", - /* 156 */ "EnumTerm", - /* 157 */ "EnumToken", - /* 158 */ "Equ", - /* 159 */ "EquTerm", - /* 160 */ "EquToken", - /* 161 */ "Exponent", - /* 162 */ "ExponentTerm", - /* 163 */ "ExponentToken", - /* 164 */ "Export", - /* 165 */ "ExportDeclaration", - /* 166 */ "ExportDeclarationGroup", - /* 167 */ "ExportDeclarationOpt", - /* 168 */ "ExportTerm", - /* 169 */ "ExportToken", - /* 170 */ "Expression", - /* 171 */ "Expression01", - /* 172 */ "Expression01List", - /* 173 */ "Expression02", - /* 174 */ "Expression02List", - /* 175 */ "Expression03", - /* 176 */ "Expression03List", - /* 177 */ "Expression04", - /* 178 */ "Expression04List", - /* 179 */ "Expression05", - /* 180 */ "Expression05List", - /* 181 */ "Expression06", - /* 182 */ "Expression06List", - /* 183 */ "Expression07", - /* 184 */ "Expression07List", - /* 185 */ "Expression08", - /* 186 */ "Expression08List", - /* 187 */ "Expression09", - /* 188 */ "Expression09List", - /* 189 */ "Expression09ListGroup", - /* 190 */ "Expression10", - /* 191 */ "Expression10List", - /* 192 */ "Expression11", - /* 193 */ "Expression11Opt", - /* 194 */ "Expression12", - /* 195 */ "Expression12List", - /* 196 */ "Expression12ListGroup", - /* 197 */ "ExpressionIdentifier", - /* 198 */ "ExpressionIdentifierList", - /* 199 */ "ExpressionIdentifierList0", - /* 200 */ "ExpressionIdentifierList0List", - /* 201 */ "ExpressionList", - /* 202 */ "F32", - /* 203 */ "F32Term", - /* 204 */ "F32Token", - /* 205 */ "F64", - /* 206 */ "F64Term", - /* 207 */ "F64Token", - /* 208 */ "Factor", - /* 209 */ "FactorGroup", - /* 210 */ "FactorOpt", - /* 211 */ "Final", - /* 212 */ "FinalDeclaration", - /* 213 */ "FinalDeclarationList", - /* 214 */ "FinalTerm", - /* 215 */ "FinalToken", - /* 216 */ "FixedPoint", - /* 217 */ "FixedPointTerm", - /* 218 */ "FixedPointToken", - /* 219 */ "FixedType", - /* 220 */ "For", - /* 221 */ "ForStatement", - /* 222 */ "ForStatementList", - /* 223 */ "ForStatementOpt", - /* 224 */ "ForTerm", - /* 225 */ "ForToken", - /* 226 */ "Function", - /* 227 */ "FunctionCall", - /* 228 */ "FunctionCallOpt", - /* 229 */ "FunctionDeclaration", - /* 230 */ "FunctionDeclarationList", - /* 231 */ "FunctionDeclarationOpt", - /* 232 */ "FunctionDeclarationOpt0", - /* 233 */ "FunctionDeclarationOpt1", - /* 234 */ "FunctionItem", - /* 235 */ "FunctionTerm", - /* 236 */ "FunctionToken", - /* 237 */ "Hash", - /* 238 */ "HashTerm", - /* 239 */ "HashToken", - /* 240 */ "HierarchicalIdentifier", - /* 241 */ "HierarchicalIdentifierList", - /* 242 */ "HierarchicalIdentifierList0", - /* 243 */ "HierarchicalIdentifierList0List", - /* 244 */ "I32", - /* 245 */ "I32Term", - /* 246 */ "I32Token", - /* 247 */ "I64", - /* 248 */ "I64Term", - /* 249 */ "I64Token", - /* 250 */ "Identifier", - /* 251 */ "IdentifierStatement", - /* 252 */ "IdentifierStatementGroup", - /* 253 */ "IdentifierTerm", - /* 254 */ "IdentifierToken", - /* 255 */ "If", - /* 256 */ "IfExpression", - /* 257 */ "IfExpressionList", - /* 258 */ "IfReset", - /* 259 */ "IfResetStatement", - /* 260 */ "IfResetStatementList", - /* 261 */ "IfResetStatementList0", - /* 262 */ "IfResetStatementList0List", - /* 263 */ "IfResetStatementOpt", - /* 264 */ "IfResetStatementOptList", - /* 265 */ "IfResetTerm", - /* 266 */ "IfResetToken", - /* 267 */ "IfStatement", - /* 268 */ "IfStatementList", - /* 269 */ "IfStatementList0", - /* 270 */ "IfStatementList0List", - /* 271 */ "IfStatementOpt", - /* 272 */ "IfStatementOptList", - /* 273 */ "IfTerm", - /* 274 */ "IfToken", - /* 275 */ "Import", - /* 276 */ "ImportDeclaration", - /* 277 */ "ImportDeclarationOpt", - /* 278 */ "ImportTerm", - /* 279 */ "ImportToken", - /* 280 */ "In", - /* 281 */ "InTerm", - /* 282 */ "InToken", - /* 283 */ "Include", - /* 284 */ "IncludeDeclaration", - /* 285 */ "IncludeTerm", - /* 286 */ "IncludeToken", - /* 287 */ "Initial", - /* 288 */ "InitialDeclaration", - /* 289 */ "InitialDeclarationList", - /* 290 */ "InitialTerm", - /* 291 */ "InitialToken", - /* 292 */ "Inout", - /* 293 */ "InoutTerm", - /* 294 */ "InoutToken", - /* 295 */ "Input", - /* 296 */ "InputTerm", - /* 297 */ "InputToken", - /* 298 */ "Inside", - /* 299 */ "InsideExpression", - /* 300 */ "InsideTerm", - /* 301 */ "InsideToken", - /* 302 */ "Inst", - /* 303 */ "InstDeclaration", - /* 304 */ "InstDeclarationOpt", - /* 305 */ "InstDeclarationOpt0", - /* 306 */ "InstDeclarationOpt1", - /* 307 */ "InstDeclarationOpt2", - /* 308 */ "InstParameter", - /* 309 */ "InstParameterGroup", - /* 310 */ "InstParameterGroupGroup", - /* 311 */ "InstParameterGroupList", - /* 312 */ "InstParameterItem", - /* 313 */ "InstParameterItemOpt", - /* 314 */ "InstParameterList", - /* 315 */ "InstParameterListList", - /* 316 */ "InstParameterListOpt", - /* 317 */ "InstParameterOpt", - /* 318 */ "InstPortGroup", - /* 319 */ "InstPortGroupGroup", - /* 320 */ "InstPortGroupList", - /* 321 */ "InstPortItem", - /* 322 */ "InstPortItemOpt", - /* 323 */ "InstPortList", - /* 324 */ "InstPortListList", - /* 325 */ "InstPortListOpt", - /* 326 */ "InstTerm", - /* 327 */ "InstToken", - /* 328 */ "IntegralNumber", - /* 329 */ "Interface", - /* 330 */ "InterfaceDeclaration", - /* 331 */ "InterfaceDeclarationList", - /* 332 */ "InterfaceDeclarationOpt", - /* 333 */ "InterfaceDeclarationOpt0", - /* 334 */ "InterfaceDeclarationOpt1", - /* 335 */ "InterfaceForDeclaration", - /* 336 */ "InterfaceForDeclarationOpt", - /* 337 */ "InterfaceGroup", - /* 338 */ "InterfaceGroupGroup", - /* 339 */ "InterfaceGroupGroupList", - /* 340 */ "InterfaceGroupList", - /* 341 */ "InterfaceIfDeclaration", - /* 342 */ "InterfaceIfDeclarationList", - /* 343 */ "InterfaceIfDeclarationOpt", - /* 344 */ "InterfaceItem", - /* 345 */ "InterfaceNamedBlock", - /* 346 */ "InterfaceNamedBlockList", - /* 347 */ "InterfaceOptionalNamedBlock", - /* 348 */ "InterfaceOptionalNamedBlockList", - /* 349 */ "InterfaceOptionalNamedBlockOpt", - /* 350 */ "InterfaceTerm", - /* 351 */ "InterfaceToken", - /* 352 */ "LAngle", - /* 353 */ "LAngleTerm", - /* 354 */ "LAngleToken", - /* 355 */ "LBrace", - /* 356 */ "LBraceTerm", - /* 357 */ "LBraceToken", - /* 358 */ "LBracket", - /* 359 */ "LBracketTerm", - /* 360 */ "LBracketToken", - /* 361 */ "LParen", - /* 362 */ "LParenTerm", - /* 363 */ "LParenToken", - /* 364 */ "Let", - /* 365 */ "LetDeclaration", - /* 366 */ "LetDeclarationOpt", - /* 367 */ "LetStatement", - /* 368 */ "LetStatementOpt", - /* 369 */ "LetTerm", - /* 370 */ "LetToken", - /* 371 */ "Local", - /* 372 */ "LocalDeclaration", - /* 373 */ "LocalDeclarationGroup", - /* 374 */ "LocalTerm", - /* 375 */ "LocalToken", - /* 376 */ "Logic", - /* 377 */ "LogicTerm", - /* 378 */ "LogicToken", - /* 379 */ "Lsb", - /* 380 */ "LsbTerm", - /* 381 */ "LsbToken", - /* 382 */ "MinusColon", - /* 383 */ "MinusColonTerm", - /* 384 */ "MinusColonToken", - /* 385 */ "MinusGT", - /* 386 */ "MinusGTTerm", - /* 387 */ "MinusGTToken", - /* 388 */ "Modport", - /* 389 */ "ModportDeclaration", - /* 390 */ "ModportGroup", - /* 391 */ "ModportGroupGroup", - /* 392 */ "ModportGroupList", - /* 393 */ "ModportItem", - /* 394 */ "ModportList", - /* 395 */ "ModportListList", - /* 396 */ "ModportListOpt", - /* 397 */ "ModportTerm", - /* 398 */ "ModportToken", - /* 399 */ "Module", - /* 400 */ "ModuleDeclaration", - /* 401 */ "ModuleDeclarationList", - /* 402 */ "ModuleDeclarationOpt", - /* 403 */ "ModuleDeclarationOpt0", - /* 404 */ "ModuleDeclarationOpt1", - /* 405 */ "ModuleDeclarationOpt2", - /* 406 */ "ModuleForDeclaration", - /* 407 */ "ModuleForDeclarationOpt", - /* 408 */ "ModuleGroup", - /* 409 */ "ModuleGroupGroup", - /* 410 */ "ModuleGroupGroupList", - /* 411 */ "ModuleGroupList", - /* 412 */ "ModuleIfDeclaration", - /* 413 */ "ModuleIfDeclarationList", - /* 414 */ "ModuleIfDeclarationOpt", - /* 415 */ "ModuleItem", - /* 416 */ "ModuleNamedBlock", - /* 417 */ "ModuleNamedBlockList", - /* 418 */ "ModuleOptionalNamedBlock", - /* 419 */ "ModuleOptionalNamedBlockList", - /* 420 */ "ModuleOptionalNamedBlockOpt", - /* 421 */ "ModuleTerm", - /* 422 */ "ModuleToken", - /* 423 */ "Msb", - /* 424 */ "MsbTerm", - /* 425 */ "MsbToken", - /* 426 */ "Number", - /* 427 */ "Operator01", - /* 428 */ "Operator01Term", - /* 429 */ "Operator01Token", - /* 430 */ "Operator02", - /* 431 */ "Operator02Term", - /* 432 */ "Operator02Token", - /* 433 */ "Operator03", - /* 434 */ "Operator03Term", - /* 435 */ "Operator03Token", - /* 436 */ "Operator04", - /* 437 */ "Operator04Term", - /* 438 */ "Operator04Token", - /* 439 */ "Operator05", - /* 440 */ "Operator05Term", - /* 441 */ "Operator05Token", - /* 442 */ "Operator06", - /* 443 */ "Operator06Term", - /* 444 */ "Operator06Token", - /* 445 */ "Operator07", - /* 446 */ "Operator07Term", - /* 447 */ "Operator07Token", - /* 448 */ "Operator08", - /* 449 */ "Operator08Term", - /* 450 */ "Operator08Token", - /* 451 */ "Operator09", - /* 452 */ "Operator09Term", - /* 453 */ "Operator09Token", - /* 454 */ "Operator10", - /* 455 */ "Operator10Term", - /* 456 */ "Operator10Token", - /* 457 */ "Operator11", - /* 458 */ "Operator11Term", - /* 459 */ "Operator11Token", - /* 460 */ "Output", - /* 461 */ "OutputTerm", - /* 462 */ "OutputToken", - /* 463 */ "Outside", - /* 464 */ "OutsideExpression", - /* 465 */ "OutsideTerm", - /* 466 */ "OutsideToken", - /* 467 */ "Package", - /* 468 */ "PackageDeclaration", - /* 469 */ "PackageDeclarationList", - /* 470 */ "PackageDeclarationOpt", - /* 471 */ "PackageDeclarationOpt0", - /* 472 */ "PackageGroup", - /* 473 */ "PackageGroupGroup", - /* 474 */ "PackageGroupGroupList", - /* 475 */ "PackageGroupList", - /* 476 */ "PackageItem", - /* 477 */ "PackageTerm", - /* 478 */ "PackageToken", - /* 479 */ "Param", - /* 480 */ "ParamTerm", - /* 481 */ "ParamToken", - /* 482 */ "PlusColon", - /* 483 */ "PlusColonTerm", - /* 484 */ "PlusColonToken", - /* 485 */ "PortDeclaration", - /* 486 */ "PortDeclarationGroup", - /* 487 */ "PortDeclarationGroupGroup", - /* 488 */ "PortDeclarationGroupList", - /* 489 */ "PortDeclarationItem", - /* 490 */ "PortDeclarationItemGroup", - /* 491 */ "PortDeclarationList", - /* 492 */ "PortDeclarationListList", - /* 493 */ "PortDeclarationListOpt", - /* 494 */ "PortDeclarationOpt", - /* 495 */ "PortTypeAbstract", - /* 496 */ "PortTypeAbstractOpt", - /* 497 */ "PortTypeAbstractOpt0", - /* 498 */ "PortTypeConcrete", - /* 499 */ "PortTypeConcreteOpt", - /* 500 */ "Pub", - /* 501 */ "PubTerm", - /* 502 */ "PubToken", - /* 503 */ "QuoteLBrace", - /* 504 */ "QuoteLBraceTerm", - /* 505 */ "QuoteLBraceToken", - /* 506 */ "RAngle", - /* 507 */ "RAngleTerm", - /* 508 */ "RAngleToken", - /* 509 */ "RBrace", - /* 510 */ "RBraceTerm", - /* 511 */ "RBraceToken", - /* 512 */ "RBracket", - /* 513 */ "RBracketTerm", - /* 514 */ "RBracketToken", - /* 515 */ "RParen", - /* 516 */ "RParenTerm", - /* 517 */ "RParenToken", - /* 518 */ "Range", - /* 519 */ "RangeItem", - /* 520 */ "RangeList", - /* 521 */ "RangeListList", - /* 522 */ "RangeListOpt", - /* 523 */ "RangeOperator", - /* 524 */ "RangeOpt", - /* 525 */ "RealNumber", - /* 526 */ "Ref", - /* 527 */ "RefTerm", - /* 528 */ "RefToken", - /* 529 */ "Repeat", - /* 530 */ "RepeatTerm", - /* 531 */ "RepeatToken", - /* 532 */ "Reset", - /* 533 */ "ResetAsyncHigh", - /* 534 */ "ResetAsyncHighTerm", - /* 535 */ "ResetAsyncHighToken", - /* 536 */ "ResetAsyncLow", - /* 537 */ "ResetAsyncLowTerm", - /* 538 */ "ResetAsyncLowToken", - /* 539 */ "ResetSyncHigh", - /* 540 */ "ResetSyncHighTerm", - /* 541 */ "ResetSyncHighToken", - /* 542 */ "ResetSyncLow", - /* 543 */ "ResetSyncLowTerm", - /* 544 */ "ResetSyncLowToken", - /* 545 */ "ResetTerm", - /* 546 */ "ResetToken", - /* 547 */ "Return", - /* 548 */ "ReturnStatement", - /* 549 */ "ReturnTerm", - /* 550 */ "ReturnToken", - /* 551 */ "ScalarType", - /* 552 */ "ScalarTypeGroup", - /* 553 */ "ScalarTypeList", - /* 554 */ "ScopedIdentifier", - /* 555 */ "ScopedIdentifierGroup", - /* 556 */ "ScopedIdentifierList", - /* 557 */ "ScopedIdentifierOpt", - /* 558 */ "ScopedIdentifierOpt0", - /* 559 */ "Select", - /* 560 */ "SelectOperator", - /* 561 */ "SelectOpt", - /* 562 */ "Semicolon", - /* 563 */ "SemicolonTerm", - /* 564 */ "SemicolonToken", - /* 565 */ "Signed", - /* 566 */ "SignedTerm", - /* 567 */ "SignedToken", - /* 568 */ "Star", - /* 569 */ "StarTerm", - /* 570 */ "StarToken", - /* 571 */ "Start", - /* 572 */ "StartToken", - /* 573 */ "Statement", - /* 574 */ "Step", - /* 575 */ "StepTerm", - /* 576 */ "StepToken", - /* 577 */ "Strin", - /* 578 */ "StringLiteral", - /* 579 */ "StringLiteralTerm", - /* 580 */ "StringLiteralToken", - /* 581 */ "StringTerm", - /* 582 */ "StringToken", - /* 583 */ "Struct", - /* 584 */ "StructTerm", - /* 585 */ "StructToken", - /* 586 */ "StructUnion", - /* 587 */ "StructUnionDeclaration", - /* 588 */ "StructUnionDeclarationOpt", - /* 589 */ "StructUnionGroup", - /* 590 */ "StructUnionGroupGroup", - /* 591 */ "StructUnionGroupList", - /* 592 */ "StructUnionItem", - /* 593 */ "StructUnionList", - /* 594 */ "StructUnionListList", - /* 595 */ "StructUnionListOpt", - /* 596 */ "Switch", - /* 597 */ "SwitchCondition", - /* 598 */ "SwitchConditionList", - /* 599 */ "SwitchExpression", - /* 600 */ "SwitchExpressionList", - /* 601 */ "SwitchExpressionOpt", - /* 602 */ "SwitchItem", - /* 603 */ "SwitchItemGroup", - /* 604 */ "SwitchItemGroup0", - /* 605 */ "SwitchItemGroup0List", - /* 606 */ "SwitchStatement", - /* 607 */ "SwitchStatementList", - /* 608 */ "SwitchTerm", - /* 609 */ "SwitchToken", - /* 610 */ "Tri", - /* 611 */ "TriTerm", - /* 612 */ "TriToken", - /* 613 */ "Type", - /* 614 */ "TypeDefDeclaration", - /* 615 */ "TypeExpression", - /* 616 */ "TypeModifier", - /* 617 */ "TypeTerm", - /* 618 */ "TypeToken", - /* 619 */ "U32", - /* 620 */ "U32Term", - /* 621 */ "U32Token", - /* 622 */ "U64", - /* 623 */ "U64Term", - /* 624 */ "U64Token", - /* 625 */ "UnaryOperator", - /* 626 */ "UnaryOperatorTerm", - /* 627 */ "UnaryOperatorToken", - /* 628 */ "Union", - /* 629 */ "UnionTerm", - /* 630 */ "UnionToken", - /* 631 */ "Unsafe", - /* 632 */ "UnsafeBlock", - /* 633 */ "UnsafeBlockList", - /* 634 */ "UnsafeTerm", - /* 635 */ "UnsafeToken", - /* 636 */ "Var", - /* 637 */ "VarDeclaration", - /* 638 */ "VarDeclarationOpt", - /* 639 */ "VarTerm", - /* 640 */ "VarToken", - /* 641 */ "VariableType", - /* 642 */ "VariableTypeGroup", - /* 643 */ "VariableTypeOpt", - /* 644 */ "Veryl", - /* 645 */ "VerylList", - /* 646 */ "Width", - /* 647 */ "WidthList", - /* 648 */ "WithGenericArgument", - /* 649 */ "WithGenericArgumentItem", - /* 650 */ "WithGenericArgumentList", - /* 651 */ "WithGenericArgumentListList", - /* 652 */ "WithGenericArgumentListOpt", - /* 653 */ "WithGenericArgumentOpt", - /* 654 */ "WithGenericParameter", - /* 655 */ "WithGenericParameterItem", - /* 656 */ "WithGenericParameterItemOpt", - /* 657 */ "WithGenericParameterList", - /* 658 */ "WithGenericParameterListList", - /* 659 */ "WithGenericParameterListOpt", - /* 660 */ "WithParameter", - /* 661 */ "WithParameterGroup", - /* 662 */ "WithParameterGroupGroup", - /* 663 */ "WithParameterGroupList", - /* 664 */ "WithParameterItem", - /* 665 */ "WithParameterItemGroup", - /* 666 */ "WithParameterItemGroup0", - /* 667 */ "WithParameterList", - /* 668 */ "WithParameterListList", - /* 669 */ "WithParameterListOpt", - /* 670 */ "WithParameterOpt", + /* 112 */ "Const", + /* 113 */ "ConstTerm", + /* 114 */ "ConstToken", + /* 115 */ "Defaul", + /* 116 */ "DefaultTerm", + /* 117 */ "DefaultToken", + /* 118 */ "DescriptionGroup", + /* 119 */ "DescriptionGroupGroup", + /* 120 */ "DescriptionGroupGroupList", + /* 121 */ "DescriptionGroupList", + /* 122 */ "DescriptionItem", + /* 123 */ "Direction", + /* 124 */ "DollarIdentifier", + /* 125 */ "DollarIdentifierTerm", + /* 126 */ "DollarIdentifierToken", + /* 127 */ "Dot", + /* 128 */ "DotDot", + /* 129 */ "DotDotEqu", + /* 130 */ "DotDotEquTerm", + /* 131 */ "DotDotEquToken", + /* 132 */ "DotDotTerm", + /* 133 */ "DotDotToken", + /* 134 */ "DotTerm", + /* 135 */ "DotToken", + /* 136 */ "Else", + /* 137 */ "ElseTerm", + /* 138 */ "ElseToken", + /* 139 */ "Embed", + /* 140 */ "EmbedContent", + /* 141 */ "EmbedContentToken", + /* 142 */ "EmbedContentTokenList", + /* 143 */ "EmbedDeclaration", + /* 144 */ "EmbedItem", + /* 145 */ "EmbedItemList", + /* 146 */ "EmbedTerm", + /* 147 */ "EmbedToken", + /* 148 */ "Enum", + /* 149 */ "EnumDeclaration", + /* 150 */ "EnumDeclarationOpt", + /* 151 */ "EnumGroup", + /* 152 */ "EnumGroupGroup", + /* 153 */ "EnumGroupList", + /* 154 */ "EnumItem", + /* 155 */ "EnumItemOpt", + /* 156 */ "EnumList", + /* 157 */ "EnumListList", + /* 158 */ "EnumListOpt", + /* 159 */ "EnumTerm", + /* 160 */ "EnumToken", + /* 161 */ "Equ", + /* 162 */ "EquTerm", + /* 163 */ "EquToken", + /* 164 */ "Exponent", + /* 165 */ "ExponentTerm", + /* 166 */ "ExponentToken", + /* 167 */ "Export", + /* 168 */ "ExportDeclaration", + /* 169 */ "ExportDeclarationGroup", + /* 170 */ "ExportDeclarationOpt", + /* 171 */ "ExportTerm", + /* 172 */ "ExportToken", + /* 173 */ "Expression", + /* 174 */ "Expression01", + /* 175 */ "Expression01List", + /* 176 */ "Expression02", + /* 177 */ "Expression02List", + /* 178 */ "Expression03", + /* 179 */ "Expression03List", + /* 180 */ "Expression04", + /* 181 */ "Expression04List", + /* 182 */ "Expression05", + /* 183 */ "Expression05List", + /* 184 */ "Expression06", + /* 185 */ "Expression06List", + /* 186 */ "Expression07", + /* 187 */ "Expression07List", + /* 188 */ "Expression08", + /* 189 */ "Expression08List", + /* 190 */ "Expression09", + /* 191 */ "Expression09List", + /* 192 */ "Expression09ListGroup", + /* 193 */ "Expression10", + /* 194 */ "Expression10List", + /* 195 */ "Expression11", + /* 196 */ "Expression11Opt", + /* 197 */ "Expression12", + /* 198 */ "Expression12List", + /* 199 */ "Expression12ListGroup", + /* 200 */ "ExpressionIdentifier", + /* 201 */ "ExpressionIdentifierList", + /* 202 */ "ExpressionIdentifierList0", + /* 203 */ "ExpressionIdentifierList0List", + /* 204 */ "ExpressionList", + /* 205 */ "F32", + /* 206 */ "F32Term", + /* 207 */ "F32Token", + /* 208 */ "F64", + /* 209 */ "F64Term", + /* 210 */ "F64Token", + /* 211 */ "Factor", + /* 212 */ "FactorGroup", + /* 213 */ "FactorOpt", + /* 214 */ "Final", + /* 215 */ "FinalDeclaration", + /* 216 */ "FinalDeclarationList", + /* 217 */ "FinalTerm", + /* 218 */ "FinalToken", + /* 219 */ "FixedPoint", + /* 220 */ "FixedPointTerm", + /* 221 */ "FixedPointToken", + /* 222 */ "FixedType", + /* 223 */ "For", + /* 224 */ "ForStatement", + /* 225 */ "ForStatementList", + /* 226 */ "ForStatementOpt", + /* 227 */ "ForTerm", + /* 228 */ "ForToken", + /* 229 */ "Function", + /* 230 */ "FunctionCall", + /* 231 */ "FunctionCallOpt", + /* 232 */ "FunctionDeclaration", + /* 233 */ "FunctionDeclarationList", + /* 234 */ "FunctionDeclarationOpt", + /* 235 */ "FunctionDeclarationOpt0", + /* 236 */ "FunctionDeclarationOpt1", + /* 237 */ "FunctionItem", + /* 238 */ "FunctionTerm", + /* 239 */ "FunctionToken", + /* 240 */ "GenericBound", + /* 241 */ "Hash", + /* 242 */ "HashTerm", + /* 243 */ "HashToken", + /* 244 */ "HierarchicalIdentifier", + /* 245 */ "HierarchicalIdentifierList", + /* 246 */ "HierarchicalIdentifierList0", + /* 247 */ "HierarchicalIdentifierList0List", + /* 248 */ "I32", + /* 249 */ "I32Term", + /* 250 */ "I32Token", + /* 251 */ "I64", + /* 252 */ "I64Term", + /* 253 */ "I64Token", + /* 254 */ "Identifier", + /* 255 */ "IdentifierStatement", + /* 256 */ "IdentifierStatementGroup", + /* 257 */ "IdentifierTerm", + /* 258 */ "IdentifierToken", + /* 259 */ "If", + /* 260 */ "IfExpression", + /* 261 */ "IfExpressionList", + /* 262 */ "IfReset", + /* 263 */ "IfResetStatement", + /* 264 */ "IfResetStatementList", + /* 265 */ "IfResetStatementList0", + /* 266 */ "IfResetStatementList0List", + /* 267 */ "IfResetStatementOpt", + /* 268 */ "IfResetStatementOptList", + /* 269 */ "IfResetTerm", + /* 270 */ "IfResetToken", + /* 271 */ "IfStatement", + /* 272 */ "IfStatementList", + /* 273 */ "IfStatementList0", + /* 274 */ "IfStatementList0List", + /* 275 */ "IfStatementOpt", + /* 276 */ "IfStatementOptList", + /* 277 */ "IfTerm", + /* 278 */ "IfToken", + /* 279 */ "Import", + /* 280 */ "ImportDeclaration", + /* 281 */ "ImportDeclarationOpt", + /* 282 */ "ImportTerm", + /* 283 */ "ImportToken", + /* 284 */ "In", + /* 285 */ "InTerm", + /* 286 */ "InToken", + /* 287 */ "Include", + /* 288 */ "IncludeDeclaration", + /* 289 */ "IncludeTerm", + /* 290 */ "IncludeToken", + /* 291 */ "Initial", + /* 292 */ "InitialDeclaration", + /* 293 */ "InitialDeclarationList", + /* 294 */ "InitialTerm", + /* 295 */ "InitialToken", + /* 296 */ "Inout", + /* 297 */ "InoutTerm", + /* 298 */ "InoutToken", + /* 299 */ "Input", + /* 300 */ "InputTerm", + /* 301 */ "InputToken", + /* 302 */ "Inside", + /* 303 */ "InsideExpression", + /* 304 */ "InsideTerm", + /* 305 */ "InsideToken", + /* 306 */ "Inst", + /* 307 */ "InstDeclaration", + /* 308 */ "InstDeclarationOpt", + /* 309 */ "InstDeclarationOpt0", + /* 310 */ "InstDeclarationOpt1", + /* 311 */ "InstDeclarationOpt2", + /* 312 */ "InstParameter", + /* 313 */ "InstParameterGroup", + /* 314 */ "InstParameterGroupGroup", + /* 315 */ "InstParameterGroupList", + /* 316 */ "InstParameterItem", + /* 317 */ "InstParameterItemOpt", + /* 318 */ "InstParameterList", + /* 319 */ "InstParameterListList", + /* 320 */ "InstParameterListOpt", + /* 321 */ "InstParameterOpt", + /* 322 */ "InstPortGroup", + /* 323 */ "InstPortGroupGroup", + /* 324 */ "InstPortGroupList", + /* 325 */ "InstPortItem", + /* 326 */ "InstPortItemOpt", + /* 327 */ "InstPortList", + /* 328 */ "InstPortListList", + /* 329 */ "InstPortListOpt", + /* 330 */ "InstTerm", + /* 331 */ "InstToken", + /* 332 */ "IntegralNumber", + /* 333 */ "Interface", + /* 334 */ "InterfaceDeclaration", + /* 335 */ "InterfaceDeclarationList", + /* 336 */ "InterfaceDeclarationOpt", + /* 337 */ "InterfaceDeclarationOpt0", + /* 338 */ "InterfaceDeclarationOpt1", + /* 339 */ "InterfaceForDeclaration", + /* 340 */ "InterfaceForDeclarationOpt", + /* 341 */ "InterfaceGroup", + /* 342 */ "InterfaceGroupGroup", + /* 343 */ "InterfaceGroupGroupList", + /* 344 */ "InterfaceGroupList", + /* 345 */ "InterfaceIfDeclaration", + /* 346 */ "InterfaceIfDeclarationList", + /* 347 */ "InterfaceIfDeclarationOpt", + /* 348 */ "InterfaceItem", + /* 349 */ "InterfaceNamedBlock", + /* 350 */ "InterfaceNamedBlockList", + /* 351 */ "InterfaceOptionalNamedBlock", + /* 352 */ "InterfaceOptionalNamedBlockList", + /* 353 */ "InterfaceOptionalNamedBlockOpt", + /* 354 */ "InterfaceTerm", + /* 355 */ "InterfaceToken", + /* 356 */ "LAngle", + /* 357 */ "LAngleTerm", + /* 358 */ "LAngleToken", + /* 359 */ "LBrace", + /* 360 */ "LBraceTerm", + /* 361 */ "LBraceToken", + /* 362 */ "LBracket", + /* 363 */ "LBracketTerm", + /* 364 */ "LBracketToken", + /* 365 */ "LParen", + /* 366 */ "LParenTerm", + /* 367 */ "LParenToken", + /* 368 */ "Let", + /* 369 */ "LetDeclaration", + /* 370 */ "LetDeclarationOpt", + /* 371 */ "LetStatement", + /* 372 */ "LetStatementOpt", + /* 373 */ "LetTerm", + /* 374 */ "LetToken", + /* 375 */ "Local", + /* 376 */ "LocalDeclaration", + /* 377 */ "LocalDeclarationGroup", + /* 378 */ "LocalTerm", + /* 379 */ "LocalToken", + /* 380 */ "Logic", + /* 381 */ "LogicTerm", + /* 382 */ "LogicToken", + /* 383 */ "Lsb", + /* 384 */ "LsbTerm", + /* 385 */ "LsbToken", + /* 386 */ "MinusColon", + /* 387 */ "MinusColonTerm", + /* 388 */ "MinusColonToken", + /* 389 */ "MinusGT", + /* 390 */ "MinusGTTerm", + /* 391 */ "MinusGTToken", + /* 392 */ "Modport", + /* 393 */ "ModportDeclaration", + /* 394 */ "ModportGroup", + /* 395 */ "ModportGroupGroup", + /* 396 */ "ModportGroupList", + /* 397 */ "ModportItem", + /* 398 */ "ModportList", + /* 399 */ "ModportListList", + /* 400 */ "ModportListOpt", + /* 401 */ "ModportTerm", + /* 402 */ "ModportToken", + /* 403 */ "Module", + /* 404 */ "ModuleDeclaration", + /* 405 */ "ModuleDeclarationList", + /* 406 */ "ModuleDeclarationOpt", + /* 407 */ "ModuleDeclarationOpt0", + /* 408 */ "ModuleDeclarationOpt1", + /* 409 */ "ModuleDeclarationOpt2", + /* 410 */ "ModuleDeclarationOpt3", + /* 411 */ "ModuleForDeclaration", + /* 412 */ "ModuleForDeclarationOpt", + /* 413 */ "ModuleGroup", + /* 414 */ "ModuleGroupGroup", + /* 415 */ "ModuleGroupGroupList", + /* 416 */ "ModuleGroupList", + /* 417 */ "ModuleIfDeclaration", + /* 418 */ "ModuleIfDeclarationList", + /* 419 */ "ModuleIfDeclarationOpt", + /* 420 */ "ModuleItem", + /* 421 */ "ModuleNamedBlock", + /* 422 */ "ModuleNamedBlockList", + /* 423 */ "ModuleOptionalNamedBlock", + /* 424 */ "ModuleOptionalNamedBlockList", + /* 425 */ "ModuleOptionalNamedBlockOpt", + /* 426 */ "ModuleTerm", + /* 427 */ "ModuleToken", + /* 428 */ "Msb", + /* 429 */ "MsbTerm", + /* 430 */ "MsbToken", + /* 431 */ "Number", + /* 432 */ "Operator01", + /* 433 */ "Operator01Term", + /* 434 */ "Operator01Token", + /* 435 */ "Operator02", + /* 436 */ "Operator02Term", + /* 437 */ "Operator02Token", + /* 438 */ "Operator03", + /* 439 */ "Operator03Term", + /* 440 */ "Operator03Token", + /* 441 */ "Operator04", + /* 442 */ "Operator04Term", + /* 443 */ "Operator04Token", + /* 444 */ "Operator05", + /* 445 */ "Operator05Term", + /* 446 */ "Operator05Token", + /* 447 */ "Operator06", + /* 448 */ "Operator06Term", + /* 449 */ "Operator06Token", + /* 450 */ "Operator07", + /* 451 */ "Operator07Term", + /* 452 */ "Operator07Token", + /* 453 */ "Operator08", + /* 454 */ "Operator08Term", + /* 455 */ "Operator08Token", + /* 456 */ "Operator09", + /* 457 */ "Operator09Term", + /* 458 */ "Operator09Token", + /* 459 */ "Operator10", + /* 460 */ "Operator10Term", + /* 461 */ "Operator10Token", + /* 462 */ "Operator11", + /* 463 */ "Operator11Term", + /* 464 */ "Operator11Token", + /* 465 */ "Output", + /* 466 */ "OutputTerm", + /* 467 */ "OutputToken", + /* 468 */ "Outside", + /* 469 */ "OutsideExpression", + /* 470 */ "OutsideTerm", + /* 471 */ "OutsideToken", + /* 472 */ "Package", + /* 473 */ "PackageDeclaration", + /* 474 */ "PackageDeclarationList", + /* 475 */ "PackageDeclarationOpt", + /* 476 */ "PackageDeclarationOpt0", + /* 477 */ "PackageGroup", + /* 478 */ "PackageGroupGroup", + /* 479 */ "PackageGroupGroupList", + /* 480 */ "PackageGroupList", + /* 481 */ "PackageItem", + /* 482 */ "PackageTerm", + /* 483 */ "PackageToken", + /* 484 */ "Param", + /* 485 */ "ParamTerm", + /* 486 */ "ParamToken", + /* 487 */ "PlusColon", + /* 488 */ "PlusColonTerm", + /* 489 */ "PlusColonToken", + /* 490 */ "PortDeclaration", + /* 491 */ "PortDeclarationGroup", + /* 492 */ "PortDeclarationGroupGroup", + /* 493 */ "PortDeclarationGroupList", + /* 494 */ "PortDeclarationItem", + /* 495 */ "PortDeclarationItemGroup", + /* 496 */ "PortDeclarationList", + /* 497 */ "PortDeclarationListList", + /* 498 */ "PortDeclarationListOpt", + /* 499 */ "PortDeclarationOpt", + /* 500 */ "PortTypeAbstract", + /* 501 */ "PortTypeAbstractOpt", + /* 502 */ "PortTypeAbstractOpt0", + /* 503 */ "PortTypeConcrete", + /* 504 */ "PortTypeConcreteOpt", + /* 505 */ "Proto", + /* 506 */ "ProtoModuleDeclaration", + /* 507 */ "ProtoModuleDeclarationOpt", + /* 508 */ "ProtoModuleDeclarationOpt0", + /* 509 */ "ProtoModuleDeclarationOpt1", + /* 510 */ "ProtoTerm", + /* 511 */ "ProtoToken", + /* 512 */ "Pub", + /* 513 */ "PubTerm", + /* 514 */ "PubToken", + /* 515 */ "QuoteLBrace", + /* 516 */ "QuoteLBraceTerm", + /* 517 */ "QuoteLBraceToken", + /* 518 */ "RAngle", + /* 519 */ "RAngleTerm", + /* 520 */ "RAngleToken", + /* 521 */ "RBrace", + /* 522 */ "RBraceTerm", + /* 523 */ "RBraceToken", + /* 524 */ "RBracket", + /* 525 */ "RBracketTerm", + /* 526 */ "RBracketToken", + /* 527 */ "RParen", + /* 528 */ "RParenTerm", + /* 529 */ "RParenToken", + /* 530 */ "Range", + /* 531 */ "RangeItem", + /* 532 */ "RangeList", + /* 533 */ "RangeListList", + /* 534 */ "RangeListOpt", + /* 535 */ "RangeOperator", + /* 536 */ "RangeOpt", + /* 537 */ "RealNumber", + /* 538 */ "Ref", + /* 539 */ "RefTerm", + /* 540 */ "RefToken", + /* 541 */ "Repeat", + /* 542 */ "RepeatTerm", + /* 543 */ "RepeatToken", + /* 544 */ "Reset", + /* 545 */ "ResetAsyncHigh", + /* 546 */ "ResetAsyncHighTerm", + /* 547 */ "ResetAsyncHighToken", + /* 548 */ "ResetAsyncLow", + /* 549 */ "ResetAsyncLowTerm", + /* 550 */ "ResetAsyncLowToken", + /* 551 */ "ResetSyncHigh", + /* 552 */ "ResetSyncHighTerm", + /* 553 */ "ResetSyncHighToken", + /* 554 */ "ResetSyncLow", + /* 555 */ "ResetSyncLowTerm", + /* 556 */ "ResetSyncLowToken", + /* 557 */ "ResetTerm", + /* 558 */ "ResetToken", + /* 559 */ "Return", + /* 560 */ "ReturnStatement", + /* 561 */ "ReturnTerm", + /* 562 */ "ReturnToken", + /* 563 */ "ScalarType", + /* 564 */ "ScalarTypeGroup", + /* 565 */ "ScalarTypeList", + /* 566 */ "ScalarTypeOpt", + /* 567 */ "ScopedIdentifier", + /* 568 */ "ScopedIdentifierGroup", + /* 569 */ "ScopedIdentifierList", + /* 570 */ "ScopedIdentifierOpt", + /* 571 */ "ScopedIdentifierOpt0", + /* 572 */ "Select", + /* 573 */ "SelectOperator", + /* 574 */ "SelectOpt", + /* 575 */ "Semicolon", + /* 576 */ "SemicolonTerm", + /* 577 */ "SemicolonToken", + /* 578 */ "Signed", + /* 579 */ "SignedTerm", + /* 580 */ "SignedToken", + /* 581 */ "Star", + /* 582 */ "StarTerm", + /* 583 */ "StarToken", + /* 584 */ "Start", + /* 585 */ "StartToken", + /* 586 */ "Statement", + /* 587 */ "Step", + /* 588 */ "StepTerm", + /* 589 */ "StepToken", + /* 590 */ "Strin", + /* 591 */ "StringLiteral", + /* 592 */ "StringLiteralTerm", + /* 593 */ "StringLiteralToken", + /* 594 */ "StringTerm", + /* 595 */ "StringToken", + /* 596 */ "Struct", + /* 597 */ "StructTerm", + /* 598 */ "StructToken", + /* 599 */ "StructUnion", + /* 600 */ "StructUnionDeclaration", + /* 601 */ "StructUnionDeclarationOpt", + /* 602 */ "StructUnionGroup", + /* 603 */ "StructUnionGroupGroup", + /* 604 */ "StructUnionGroupList", + /* 605 */ "StructUnionItem", + /* 606 */ "StructUnionList", + /* 607 */ "StructUnionListList", + /* 608 */ "StructUnionListOpt", + /* 609 */ "Switch", + /* 610 */ "SwitchCondition", + /* 611 */ "SwitchConditionList", + /* 612 */ "SwitchExpression", + /* 613 */ "SwitchExpressionList", + /* 614 */ "SwitchExpressionOpt", + /* 615 */ "SwitchItem", + /* 616 */ "SwitchItemGroup", + /* 617 */ "SwitchItemGroup0", + /* 618 */ "SwitchItemGroup0List", + /* 619 */ "SwitchStatement", + /* 620 */ "SwitchStatementList", + /* 621 */ "SwitchTerm", + /* 622 */ "SwitchToken", + /* 623 */ "Tri", + /* 624 */ "TriTerm", + /* 625 */ "TriToken", + /* 626 */ "Type", + /* 627 */ "TypeDefDeclaration", + /* 628 */ "TypeExpression", + /* 629 */ "TypeModifier", + /* 630 */ "TypeTerm", + /* 631 */ "TypeToken", + /* 632 */ "U32", + /* 633 */ "U32Term", + /* 634 */ "U32Token", + /* 635 */ "U64", + /* 636 */ "U64Term", + /* 637 */ "U64Token", + /* 638 */ "UnaryOperator", + /* 639 */ "UnaryOperatorTerm", + /* 640 */ "UnaryOperatorToken", + /* 641 */ "Union", + /* 642 */ "UnionTerm", + /* 643 */ "UnionToken", + /* 644 */ "Unsafe", + /* 645 */ "UnsafeBlock", + /* 646 */ "UnsafeBlockList", + /* 647 */ "UnsafeTerm", + /* 648 */ "UnsafeToken", + /* 649 */ "Var", + /* 650 */ "VarDeclaration", + /* 651 */ "VarDeclarationOpt", + /* 652 */ "VarTerm", + /* 653 */ "VarToken", + /* 654 */ "VariableType", + /* 655 */ "Veryl", + /* 656 */ "VerylList", + /* 657 */ "Width", + /* 658 */ "WidthList", + /* 659 */ "WithGenericArgument", + /* 660 */ "WithGenericArgumentItem", + /* 661 */ "WithGenericArgumentList", + /* 662 */ "WithGenericArgumentListList", + /* 663 */ "WithGenericArgumentListOpt", + /* 664 */ "WithGenericArgumentOpt", + /* 665 */ "WithGenericParameter", + /* 666 */ "WithGenericParameterItem", + /* 667 */ "WithGenericParameterItemOpt", + /* 668 */ "WithGenericParameterList", + /* 669 */ "WithGenericParameterListList", + /* 670 */ "WithGenericParameterListOpt", + /* 671 */ "WithParameter", + /* 672 */ "WithParameterGroup", + /* 673 */ "WithParameterGroupGroup", + /* 674 */ "WithParameterGroupList", + /* 675 */ "WithParameterItem", + /* 676 */ "WithParameterItemGroup", + /* 677 */ "WithParameterItemGroup0", + /* 678 */ "WithParameterList", + /* 679 */ "WithParameterListList", + /* 680 */ "WithParameterListOpt", + /* 681 */ "WithParameterOpt", ]; -pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ +pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 682] = &[ /* 0 - "AllBit" */ LookaheadDFA { - prod0: 232, + prod0: 236, transitions: &[], k: 0, }, @@ -1200,31 +1219,31 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ }, /* 2 - "AllBitToken" */ LookaheadDFA { - prod0: 121, + prod0: 123, transitions: &[], k: 0, }, /* 3 - "AlwayfFfEventList" */ LookaheadDFA { - prod0: 642, + prod0: 647, transitions: &[], k: 0, }, /* 4 - "AlwayfFfEventListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 643), Trans(0, 46, 2, 644)], + transitions: &[Trans(0, 32, 1, 648), Trans(0, 46, 2, 649)], k: 1, }, /* 5 - "AlwaysComb" */ LookaheadDFA { - prod0: 270, + prod0: 274, transitions: &[], k: 0, }, /* 6 - "AlwaysCombDeclaration" */ LookaheadDFA { - prod0: 647, + prod0: 652, transitions: &[], k: 0, }, @@ -1232,17 +1251,17 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 649), - Trans(0, 54, 1, 648), - Trans(0, 66, 1, 648), - Trans(0, 70, 1, 648), - Trans(0, 71, 1, 648), - Trans(0, 81, 1, 648), - Trans(0, 100, 1, 648), - Trans(0, 101, 1, 648), - Trans(0, 106, 1, 648), - Trans(0, 114, 1, 648), - Trans(0, 115, 1, 648), + Trans(0, 44, 2, 654), + Trans(0, 54, 1, 653), + Trans(0, 67, 1, 653), + Trans(0, 71, 1, 653), + Trans(0, 72, 1, 653), + Trans(0, 82, 1, 653), + Trans(0, 102, 1, 653), + Trans(0, 103, 1, 653), + Trans(0, 108, 1, 653), + Trans(0, 116, 1, 653), + Trans(0, 117, 1, 653), ], k: 1, }, @@ -1254,25 +1273,25 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ }, /* 9 - "AlwaysCombToken" */ LookaheadDFA { - prod0: 159, + prod0: 161, transitions: &[], k: 0, }, /* 10 - "AlwaysFf" */ LookaheadDFA { - prod0: 271, + prod0: 275, transitions: &[], k: 0, }, /* 11 - "AlwaysFfClock" */ LookaheadDFA { - prod0: 645, + prod0: 650, transitions: &[], k: 0, }, /* 12 - "AlwaysFfDeclaration" */ LookaheadDFA { - prod0: 637, + prod0: 642, transitions: &[], k: 0, }, @@ -1280,29 +1299,29 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 639), - Trans(0, 54, 1, 638), - Trans(0, 66, 1, 638), - Trans(0, 70, 1, 638), - Trans(0, 71, 1, 638), - Trans(0, 81, 1, 638), - Trans(0, 100, 1, 638), - Trans(0, 101, 1, 638), - Trans(0, 106, 1, 638), - Trans(0, 114, 1, 638), - Trans(0, 115, 1, 638), + Trans(0, 44, 2, 644), + Trans(0, 54, 1, 643), + Trans(0, 67, 1, 643), + Trans(0, 71, 1, 643), + Trans(0, 72, 1, 643), + Trans(0, 82, 1, 643), + Trans(0, 102, 1, 643), + Trans(0, 103, 1, 643), + Trans(0, 108, 1, 643), + Trans(0, 116, 1, 643), + Trans(0, 117, 1, 643), ], k: 1, }, /* 14 - "AlwaysFfDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 2, 641), Trans(0, 42, 1, 640)], + transitions: &[Trans(0, 40, 2, 646), Trans(0, 42, 1, 645)], k: 1, }, /* 15 - "AlwaysFfReset" */ LookaheadDFA { - prod0: 646, + prod0: 651, transitions: &[], k: 0, }, @@ -1314,25 +1333,25 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ }, /* 17 - "AlwaysFfToken" */ LookaheadDFA { - prod0: 160, + prod0: 162, transitions: &[], k: 0, }, /* 18 - "AnyTerm" */ LookaheadDFA { - prod0: 111, + prod0: 113, transitions: &[], k: 0, }, /* 19 - "ArgumentItem" */ LookaheadDFA { - prod0: 437, + prod0: 443, transitions: &[], k: 0, }, /* 20 - "ArgumentList" */ LookaheadDFA { - prod0: 432, + prod0: 438, transitions: &[], k: 0, }, @@ -1359,146 +1378,146 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 42, 4, -1), Trans(1, 46, 24, -1), Trans(1, 54, 4, -1), - Trans(1, 71, 4, -1), - Trans(1, 77, 4, -1), - Trans(1, 84, 2, -1), - Trans(1, 87, 2, -1), - Trans(1, 89, 4, -1), - Trans(1, 106, 6, -1), - Trans(1, 114, 7, -1), - Trans(1, 115, 8, -1), - Trans(2, 5, 3, 433), - Trans(2, 16, 3, 433), - Trans(2, 17, 3, 433), - Trans(2, 18, 3, 433), - Trans(2, 19, 3, 433), - Trans(2, 20, 3, 433), - Trans(2, 21, 3, 433), - Trans(2, 22, 3, 433), - Trans(2, 23, 3, 433), - Trans(2, 24, 3, 433), - Trans(2, 25, 3, 433), - Trans(2, 26, 3, 433), - Trans(2, 32, 3, 433), - Trans(2, 46, 3, 433), - Trans(2, 48, 3, 433), - Trans(2, 52, 3, 433), - Trans(4, 5, 3, 433), - Trans(4, 6, 3, 433), - Trans(4, 7, 3, 433), - Trans(4, 8, 3, 433), - Trans(4, 9, 3, 433), - Trans(4, 10, 3, 433), - Trans(4, 11, 3, 433), - Trans(4, 18, 3, 433), - Trans(4, 24, 3, 433), - Trans(4, 25, 3, 433), - Trans(4, 26, 3, 433), - Trans(4, 27, 3, 433), - Trans(4, 39, 3, 433), - Trans(4, 40, 3, 433), - Trans(4, 42, 3, 433), - Trans(4, 54, 3, 433), - Trans(4, 71, 3, 433), - Trans(4, 77, 3, 433), - Trans(4, 84, 3, 433), - Trans(4, 87, 3, 433), - Trans(4, 89, 3, 433), - Trans(4, 106, 3, 433), - Trans(4, 114, 3, 433), - Trans(4, 115, 3, 433), - Trans(5, 5, 3, 433), - Trans(5, 6, 3, 433), - Trans(5, 7, 3, 433), - Trans(5, 8, 3, 433), - Trans(5, 9, 3, 433), - Trans(5, 10, 3, 433), - Trans(5, 11, 3, 433), - Trans(5, 18, 3, 433), - Trans(5, 24, 3, 433), - Trans(5, 25, 3, 433), - Trans(5, 26, 3, 433), - Trans(5, 27, 3, 433), - Trans(5, 39, 3, 433), - Trans(5, 40, 3, 433), - Trans(5, 42, 3, 433), - Trans(5, 54, 3, 433), - Trans(5, 58, 3, 433), - Trans(5, 71, 3, 433), - Trans(5, 77, 3, 433), - Trans(5, 84, 3, 433), - Trans(5, 87, 3, 433), - Trans(5, 89, 3, 433), - Trans(5, 106, 3, 433), - Trans(5, 114, 3, 433), - Trans(5, 115, 3, 433), - Trans(6, 5, 3, 433), - Trans(6, 40, 3, 433), - Trans(7, 5, 3, 433), - Trans(7, 16, 3, 433), - Trans(7, 17, 3, 433), - Trans(7, 18, 3, 433), - Trans(7, 19, 3, 433), - Trans(7, 20, 3, 433), - Trans(7, 21, 3, 433), - Trans(7, 22, 3, 433), - Trans(7, 23, 3, 433), - Trans(7, 24, 3, 433), - Trans(7, 25, 3, 433), - Trans(7, 26, 3, 433), - Trans(7, 30, 3, 433), - Trans(7, 32, 3, 433), - Trans(7, 35, 3, 433), - Trans(7, 41, 3, 433), - Trans(7, 42, 3, 433), - Trans(7, 46, 3, 433), - Trans(7, 48, 3, 433), - Trans(7, 52, 3, 433), - Trans(8, 5, 3, 433), - Trans(8, 16, 3, 433), - Trans(8, 17, 3, 433), - Trans(8, 18, 3, 433), - Trans(8, 19, 3, 433), - Trans(8, 20, 3, 433), - Trans(8, 21, 3, 433), - Trans(8, 22, 3, 433), - Trans(8, 23, 3, 433), - Trans(8, 24, 3, 433), - Trans(8, 25, 3, 433), - Trans(8, 26, 3, 433), - Trans(8, 29, 3, 433), - Trans(8, 30, 3, 433), - Trans(8, 32, 3, 433), - Trans(8, 35, 3, 433), - Trans(8, 41, 3, 433), - Trans(8, 42, 3, 433), - Trans(8, 46, 3, 433), - Trans(8, 48, 3, 433), - Trans(8, 52, 3, 433), - Trans(9, 6, 3, 433), - Trans(9, 7, 3, 433), - Trans(9, 8, 3, 433), - Trans(9, 9, 3, 433), - Trans(9, 10, 3, 433), - Trans(9, 11, 3, 433), - Trans(9, 18, 3, 433), - Trans(9, 24, 3, 433), - Trans(9, 25, 3, 433), - Trans(9, 26, 3, 433), - Trans(9, 27, 3, 433), - Trans(9, 39, 3, 433), - Trans(9, 40, 3, 433), - Trans(9, 42, 3, 433), - Trans(9, 46, 23, 434), - Trans(9, 54, 3, 433), - Trans(9, 71, 3, 433), - Trans(9, 77, 3, 433), - Trans(9, 84, 3, 433), - Trans(9, 87, 3, 433), - Trans(9, 89, 3, 433), - Trans(9, 106, 3, 433), - Trans(9, 114, 3, 433), - Trans(9, 115, 3, 433), + Trans(1, 72, 4, -1), + Trans(1, 78, 4, -1), + Trans(1, 85, 2, -1), + Trans(1, 88, 2, -1), + Trans(1, 90, 4, -1), + Trans(1, 108, 6, -1), + Trans(1, 116, 7, -1), + Trans(1, 117, 8, -1), + Trans(2, 5, 3, 439), + Trans(2, 16, 3, 439), + Trans(2, 17, 3, 439), + Trans(2, 18, 3, 439), + Trans(2, 19, 3, 439), + Trans(2, 20, 3, 439), + Trans(2, 21, 3, 439), + Trans(2, 22, 3, 439), + Trans(2, 23, 3, 439), + Trans(2, 24, 3, 439), + Trans(2, 25, 3, 439), + Trans(2, 26, 3, 439), + Trans(2, 32, 3, 439), + Trans(2, 46, 3, 439), + Trans(2, 48, 3, 439), + Trans(2, 52, 3, 439), + Trans(4, 5, 3, 439), + Trans(4, 6, 3, 439), + Trans(4, 7, 3, 439), + Trans(4, 8, 3, 439), + Trans(4, 9, 3, 439), + Trans(4, 10, 3, 439), + Trans(4, 11, 3, 439), + Trans(4, 18, 3, 439), + Trans(4, 24, 3, 439), + Trans(4, 25, 3, 439), + Trans(4, 26, 3, 439), + Trans(4, 27, 3, 439), + Trans(4, 39, 3, 439), + Trans(4, 40, 3, 439), + Trans(4, 42, 3, 439), + Trans(4, 54, 3, 439), + Trans(4, 72, 3, 439), + Trans(4, 78, 3, 439), + Trans(4, 85, 3, 439), + Trans(4, 88, 3, 439), + Trans(4, 90, 3, 439), + Trans(4, 108, 3, 439), + Trans(4, 116, 3, 439), + Trans(4, 117, 3, 439), + Trans(5, 5, 3, 439), + Trans(5, 6, 3, 439), + Trans(5, 7, 3, 439), + Trans(5, 8, 3, 439), + Trans(5, 9, 3, 439), + Trans(5, 10, 3, 439), + Trans(5, 11, 3, 439), + Trans(5, 18, 3, 439), + Trans(5, 24, 3, 439), + Trans(5, 25, 3, 439), + Trans(5, 26, 3, 439), + Trans(5, 27, 3, 439), + Trans(5, 39, 3, 439), + Trans(5, 40, 3, 439), + Trans(5, 42, 3, 439), + Trans(5, 54, 3, 439), + Trans(5, 59, 3, 439), + Trans(5, 72, 3, 439), + Trans(5, 78, 3, 439), + Trans(5, 85, 3, 439), + Trans(5, 88, 3, 439), + Trans(5, 90, 3, 439), + Trans(5, 108, 3, 439), + Trans(5, 116, 3, 439), + Trans(5, 117, 3, 439), + Trans(6, 5, 3, 439), + Trans(6, 40, 3, 439), + Trans(7, 5, 3, 439), + Trans(7, 16, 3, 439), + Trans(7, 17, 3, 439), + Trans(7, 18, 3, 439), + Trans(7, 19, 3, 439), + Trans(7, 20, 3, 439), + Trans(7, 21, 3, 439), + Trans(7, 22, 3, 439), + Trans(7, 23, 3, 439), + Trans(7, 24, 3, 439), + Trans(7, 25, 3, 439), + Trans(7, 26, 3, 439), + Trans(7, 30, 3, 439), + Trans(7, 32, 3, 439), + Trans(7, 35, 3, 439), + Trans(7, 41, 3, 439), + Trans(7, 42, 3, 439), + Trans(7, 46, 3, 439), + Trans(7, 48, 3, 439), + Trans(7, 52, 3, 439), + Trans(8, 5, 3, 439), + Trans(8, 16, 3, 439), + Trans(8, 17, 3, 439), + Trans(8, 18, 3, 439), + Trans(8, 19, 3, 439), + Trans(8, 20, 3, 439), + Trans(8, 21, 3, 439), + Trans(8, 22, 3, 439), + Trans(8, 23, 3, 439), + Trans(8, 24, 3, 439), + Trans(8, 25, 3, 439), + Trans(8, 26, 3, 439), + Trans(8, 29, 3, 439), + Trans(8, 30, 3, 439), + Trans(8, 32, 3, 439), + Trans(8, 35, 3, 439), + Trans(8, 41, 3, 439), + Trans(8, 42, 3, 439), + Trans(8, 46, 3, 439), + Trans(8, 48, 3, 439), + Trans(8, 52, 3, 439), + Trans(9, 6, 3, 439), + Trans(9, 7, 3, 439), + Trans(9, 8, 3, 439), + Trans(9, 9, 3, 439), + Trans(9, 10, 3, 439), + Trans(9, 11, 3, 439), + Trans(9, 18, 3, 439), + Trans(9, 24, 3, 439), + Trans(9, 25, 3, 439), + Trans(9, 26, 3, 439), + Trans(9, 27, 3, 439), + Trans(9, 39, 3, 439), + Trans(9, 40, 3, 439), + Trans(9, 42, 3, 439), + Trans(9, 46, 23, 440), + Trans(9, 54, 3, 439), + Trans(9, 72, 3, 439), + Trans(9, 78, 3, 439), + Trans(9, 85, 3, 439), + Trans(9, 88, 3, 439), + Trans(9, 90, 3, 439), + Trans(9, 108, 3, 439), + Trans(9, 116, 3, 439), + Trans(9, 117, 3, 439), Trans(10, 5, 11, -1), Trans(10, 12, 12, -1), Trans(10, 14, 12, -1), @@ -1525,2050 +1544,8 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(10, 47, 20, -1), Trans(10, 48, 12, -1), Trans(10, 52, 21, -1), - Trans(10, 94, 12, -1), - Trans(10, 103, 22, -1), - Trans(11, 12, 23, 434), - Trans(11, 14, 23, 434), - Trans(11, 16, 23, 434), - Trans(11, 17, 23, 434), - Trans(11, 18, 23, 434), - Trans(11, 19, 23, 434), - Trans(11, 20, 23, 434), - Trans(11, 21, 23, 434), - Trans(11, 22, 23, 434), - Trans(11, 23, 23, 434), - Trans(11, 24, 23, 434), - Trans(11, 25, 23, 434), - Trans(11, 26, 23, 434), - Trans(11, 31, 23, 434), - Trans(11, 32, 23, 434), - Trans(11, 33, 23, 434), - Trans(11, 34, 23, 434), - Trans(11, 40, 23, 434), - Trans(11, 43, 23, 434), - Trans(11, 44, 23, 434), - Trans(11, 45, 23, 434), - Trans(11, 46, 23, 434), - Trans(11, 47, 23, 434), - Trans(11, 48, 23, 434), - Trans(11, 52, 23, 434), - Trans(11, 94, 23, 434), - Trans(11, 103, 23, 434), - Trans(12, 5, 23, 434), - Trans(12, 6, 23, 434), - Trans(12, 7, 23, 434), - Trans(12, 8, 23, 434), - Trans(12, 9, 23, 434), - Trans(12, 10, 23, 434), - Trans(12, 11, 23, 434), - Trans(12, 18, 23, 434), - Trans(12, 24, 23, 434), - Trans(12, 25, 23, 434), - Trans(12, 26, 23, 434), - Trans(12, 27, 23, 434), - Trans(12, 39, 23, 434), - Trans(12, 40, 23, 434), - Trans(12, 42, 23, 434), - Trans(12, 54, 23, 434), - Trans(12, 71, 23, 434), - Trans(12, 77, 23, 434), - Trans(12, 84, 23, 434), - Trans(12, 87, 23, 434), - Trans(12, 89, 23, 434), - Trans(12, 106, 23, 434), - Trans(12, 114, 23, 434), - Trans(12, 115, 23, 434), - Trans(13, 5, 23, 434), - Trans(13, 6, 23, 434), - Trans(13, 7, 23, 434), - Trans(13, 8, 23, 434), - Trans(13, 9, 23, 434), - Trans(13, 10, 23, 434), - Trans(13, 11, 23, 434), - Trans(13, 18, 23, 434), - Trans(13, 24, 23, 434), - Trans(13, 25, 23, 434), - Trans(13, 26, 23, 434), - Trans(13, 27, 23, 434), - Trans(13, 39, 23, 434), - Trans(13, 40, 23, 434), - Trans(13, 42, 23, 434), - Trans(13, 54, 23, 434), - Trans(13, 66, 23, 434), - Trans(13, 70, 23, 434), - Trans(13, 71, 23, 434), - Trans(13, 77, 23, 434), - Trans(13, 81, 23, 434), - Trans(13, 84, 23, 434), - Trans(13, 87, 23, 434), - Trans(13, 89, 23, 434), - Trans(13, 100, 23, 434), - Trans(13, 101, 23, 434), - Trans(13, 106, 23, 434), - Trans(13, 114, 23, 434), - Trans(13, 115, 23, 434), - Trans(14, 5, 23, 434), - Trans(14, 6, 23, 434), - Trans(14, 7, 23, 434), - Trans(14, 8, 23, 434), - Trans(14, 9, 23, 434), - Trans(14, 10, 23, 434), - Trans(14, 11, 23, 434), - Trans(14, 18, 23, 434), - Trans(14, 24, 23, 434), - Trans(14, 25, 23, 434), - Trans(14, 26, 23, 434), - Trans(14, 27, 23, 434), - Trans(14, 37, 23, 434), - Trans(14, 39, 23, 434), - Trans(14, 40, 23, 434), - Trans(14, 42, 23, 434), - Trans(14, 44, 23, 434), - Trans(14, 46, 23, 434), - Trans(14, 54, 23, 434), - Trans(14, 58, 23, 434), - Trans(14, 71, 23, 434), - Trans(14, 77, 23, 434), - Trans(14, 82, 23, 434), - Trans(14, 84, 23, 434), - Trans(14, 87, 23, 434), - Trans(14, 89, 23, 434), - Trans(14, 91, 23, 434), - Trans(14, 106, 23, 434), - Trans(14, 114, 23, 434), - Trans(14, 115, 23, 434), - Trans(15, 5, 23, 434), - Trans(15, 6, 23, 434), - Trans(15, 7, 23, 434), - Trans(15, 8, 23, 434), - Trans(15, 9, 23, 434), - Trans(15, 10, 23, 434), - Trans(15, 11, 23, 434), - Trans(15, 18, 23, 434), - Trans(15, 24, 23, 434), - Trans(15, 25, 23, 434), - Trans(15, 26, 23, 434), - Trans(15, 27, 23, 434), - Trans(15, 31, 23, 434), - Trans(15, 37, 23, 434), - Trans(15, 39, 23, 434), - Trans(15, 40, 23, 434), - Trans(15, 42, 23, 434), - Trans(15, 44, 23, 434), - Trans(15, 49, 23, 434), - Trans(15, 50, 23, 434), - Trans(15, 51, 23, 434), - Trans(15, 54, 23, 434), - Trans(15, 58, 23, 434), - Trans(15, 61, 23, 434), - Trans(15, 65, 23, 434), - Trans(15, 66, 23, 434), - Trans(15, 67, 23, 434), - Trans(15, 70, 23, 434), - Trans(15, 71, 23, 434), - Trans(15, 72, 23, 434), - Trans(15, 74, 23, 434), - Trans(15, 77, 23, 434), - Trans(15, 78, 23, 434), - Trans(15, 81, 23, 434), - Trans(15, 82, 23, 434), - Trans(15, 84, 23, 434), - Trans(15, 85, 23, 434), - Trans(15, 87, 23, 434), - Trans(15, 89, 23, 434), - Trans(15, 100, 23, 434), - Trans(15, 101, 23, 434), - Trans(15, 105, 23, 434), - Trans(15, 106, 23, 434), - Trans(15, 108, 23, 434), - Trans(15, 111, 23, 434), - Trans(15, 112, 23, 434), - Trans(15, 113, 23, 434), - Trans(15, 114, 23, 434), - Trans(15, 115, 23, 434), - Trans(16, 5, 23, 434), - Trans(16, 32, 23, 434), - Trans(16, 36, 23, 434), - Trans(16, 40, 23, 434), - Trans(16, 41, 23, 434), - Trans(16, 44, 23, 434), - Trans(16, 46, 23, 434), - Trans(16, 47, 23, 434), - Trans(16, 80, 23, 434), - Trans(17, 5, 23, 434), - Trans(17, 12, 23, 434), - Trans(17, 14, 23, 434), - Trans(17, 16, 23, 434), - Trans(17, 17, 23, 434), - Trans(17, 18, 23, 434), - Trans(17, 19, 23, 434), - Trans(17, 20, 23, 434), - Trans(17, 21, 23, 434), - Trans(17, 22, 23, 434), - Trans(17, 23, 23, 434), - Trans(17, 24, 23, 434), - Trans(17, 25, 23, 434), - Trans(17, 26, 23, 434), - Trans(17, 31, 23, 434), - Trans(17, 32, 23, 434), - Trans(17, 33, 23, 434), - Trans(17, 34, 23, 434), - Trans(17, 37, 23, 434), - Trans(17, 40, 23, 434), - Trans(17, 43, 23, 434), - Trans(17, 44, 23, 434), - Trans(17, 45, 23, 434), - Trans(17, 46, 23, 434), - Trans(17, 47, 23, 434), - Trans(17, 48, 23, 434), - Trans(17, 49, 23, 434), - Trans(17, 50, 23, 434), - Trans(17, 51, 23, 434), - Trans(17, 52, 23, 434), - Trans(17, 59, 23, 434), - Trans(17, 61, 23, 434), - Trans(17, 62, 23, 434), - Trans(17, 65, 23, 434), - Trans(17, 66, 23, 434), - Trans(17, 67, 23, 434), - Trans(17, 71, 23, 434), - Trans(17, 72, 23, 434), - Trans(17, 74, 23, 434), - Trans(17, 78, 23, 434), - Trans(17, 81, 23, 434), - Trans(17, 82, 23, 434), - Trans(17, 85, 23, 434), - Trans(17, 94, 23, 434), - Trans(17, 103, 23, 434), - Trans(17, 105, 23, 434), - Trans(17, 108, 23, 434), - Trans(17, 111, 23, 434), - Trans(17, 112, 23, 434), - Trans(17, 113, 23, 434), - Trans(18, 5, 23, 434), - Trans(18, 12, 23, 434), - Trans(18, 14, 23, 434), - Trans(18, 15, 23, 434), - Trans(18, 16, 23, 434), - Trans(18, 17, 23, 434), - Trans(18, 18, 23, 434), - Trans(18, 19, 23, 434), - Trans(18, 20, 23, 434), - Trans(18, 21, 23, 434), - Trans(18, 22, 23, 434), - Trans(18, 23, 23, 434), - Trans(18, 24, 23, 434), - Trans(18, 25, 23, 434), - Trans(18, 26, 23, 434), - Trans(18, 31, 23, 434), - Trans(18, 32, 23, 434), - Trans(18, 33, 23, 434), - Trans(18, 34, 23, 434), - Trans(18, 35, 23, 434), - Trans(18, 36, 23, 434), - Trans(18, 37, 23, 434), - Trans(18, 40, 23, 434), - Trans(18, 41, 23, 434), - Trans(18, 42, 23, 434), - Trans(18, 43, 23, 434), - Trans(18, 44, 23, 434), - Trans(18, 45, 23, 434), - Trans(18, 46, 23, 434), - Trans(18, 47, 23, 434), - Trans(18, 48, 23, 434), - Trans(18, 52, 23, 434), - Trans(18, 94, 23, 434), - Trans(18, 103, 23, 434), - Trans(19, 5, 23, 434), - Trans(19, 12, 23, 434), - Trans(19, 14, 23, 434), - Trans(19, 16, 23, 434), - Trans(19, 17, 23, 434), - Trans(19, 18, 23, 434), - Trans(19, 19, 23, 434), - Trans(19, 20, 23, 434), - Trans(19, 21, 23, 434), - Trans(19, 22, 23, 434), - Trans(19, 23, 23, 434), - Trans(19, 24, 23, 434), - Trans(19, 25, 23, 434), - Trans(19, 26, 23, 434), - Trans(19, 31, 23, 434), - Trans(19, 32, 23, 434), - Trans(19, 33, 23, 434), - Trans(19, 34, 23, 434), - Trans(19, 40, 23, 434), - Trans(19, 42, 23, 434), - Trans(19, 43, 23, 434), - Trans(19, 44, 23, 434), - Trans(19, 45, 23, 434), - Trans(19, 46, 23, 434), - Trans(19, 47, 23, 434), - Trans(19, 48, 23, 434), - Trans(19, 52, 23, 434), - Trans(19, 94, 23, 434), - Trans(19, 103, 23, 434), - Trans(20, 5, 23, 434), - Trans(20, 6, 23, 434), - Trans(20, 7, 23, 434), - Trans(20, 8, 23, 434), - Trans(20, 9, 23, 434), - Trans(20, 10, 23, 434), - Trans(20, 11, 23, 434), - Trans(20, 18, 23, 434), - Trans(20, 24, 23, 434), - Trans(20, 25, 23, 434), - Trans(20, 26, 23, 434), - Trans(20, 27, 23, 434), - Trans(20, 31, 23, 434), - Trans(20, 37, 23, 434), - Trans(20, 39, 23, 434), - Trans(20, 40, 23, 434), - Trans(20, 42, 23, 434), - Trans(20, 44, 23, 434), - Trans(20, 49, 23, 434), - Trans(20, 50, 23, 434), - Trans(20, 51, 23, 434), - Trans(20, 54, 23, 434), - Trans(20, 58, 23, 434), - Trans(20, 61, 23, 434), - Trans(20, 62, 23, 434), - Trans(20, 65, 23, 434), - Trans(20, 66, 23, 434), - Trans(20, 67, 23, 434), - Trans(20, 70, 23, 434), - Trans(20, 71, 23, 434), - Trans(20, 72, 23, 434), - Trans(20, 74, 23, 434), - Trans(20, 77, 23, 434), - Trans(20, 78, 23, 434), - Trans(20, 81, 23, 434), - Trans(20, 82, 23, 434), - Trans(20, 84, 23, 434), - Trans(20, 85, 23, 434), - Trans(20, 87, 23, 434), - Trans(20, 89, 23, 434), - Trans(20, 100, 23, 434), - Trans(20, 101, 23, 434), - Trans(20, 105, 23, 434), - Trans(20, 106, 23, 434), - Trans(20, 108, 23, 434), - Trans(20, 111, 23, 434), - Trans(20, 112, 23, 434), - Trans(20, 113, 23, 434), - Trans(20, 114, 23, 434), - Trans(20, 115, 23, 434), - Trans(21, 5, 23, 434), - Trans(21, 55, 23, 434), - Trans(21, 56, 23, 434), - Trans(21, 57, 23, 434), - Trans(21, 63, 23, 434), - Trans(21, 64, 23, 434), - Trans(21, 68, 23, 434), - Trans(21, 69, 23, 434), - Trans(21, 95, 23, 434), - Trans(21, 96, 23, 434), - Trans(21, 97, 23, 434), - Trans(21, 98, 23, 434), - Trans(21, 99, 23, 434), - Trans(21, 109, 23, 434), - Trans(21, 110, 23, 434), - Trans(21, 114, 23, 434), - Trans(21, 115, 23, 434), - Trans(22, 5, 23, 434), - Trans(22, 6, 23, 434), - Trans(22, 7, 23, 434), - Trans(22, 8, 23, 434), - Trans(22, 9, 23, 434), - Trans(22, 10, 23, 434), - Trans(22, 11, 23, 434), - Trans(22, 15, 23, 434), - Trans(22, 18, 23, 434), - Trans(22, 24, 23, 434), - Trans(22, 25, 23, 434), - Trans(22, 26, 23, 434), - Trans(22, 27, 23, 434), - Trans(22, 39, 23, 434), - Trans(22, 40, 23, 434), - Trans(22, 42, 23, 434), - Trans(22, 54, 23, 434), - Trans(22, 71, 23, 434), - Trans(22, 77, 23, 434), - Trans(22, 84, 23, 434), - Trans(22, 87, 23, 434), - Trans(22, 89, 23, 434), - Trans(22, 106, 23, 434), - Trans(22, 114, 23, 434), - Trans(22, 115, 23, 434), - Trans(24, 5, 23, 434), - Trans(24, 12, 23, 434), - Trans(24, 14, 23, 434), - Trans(24, 16, 23, 434), - Trans(24, 17, 23, 434), - Trans(24, 18, 23, 434), - Trans(24, 19, 23, 434), - Trans(24, 20, 23, 434), - Trans(24, 21, 23, 434), - Trans(24, 22, 23, 434), - Trans(24, 23, 23, 434), - Trans(24, 24, 23, 434), - Trans(24, 25, 23, 434), - Trans(24, 26, 23, 434), - Trans(24, 31, 23, 434), - Trans(24, 32, 23, 434), - Trans(24, 33, 23, 434), - Trans(24, 34, 23, 434), - Trans(24, 40, 23, 434), - Trans(24, 43, 23, 434), - Trans(24, 44, 23, 434), - Trans(24, 45, 23, 434), - Trans(24, 46, 23, 434), - Trans(24, 47, 23, 434), - Trans(24, 48, 23, 434), - Trans(24, 52, 23, 434), - Trans(24, 94, 23, 434), - Trans(24, 103, 23, 434), - ], - k: 3, - }, - /* 22 - "ArgumentListOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 32, 1, 435), Trans(0, 46, 2, 436)], - k: 1, - }, - /* 23 - "Array" */ - LookaheadDFA { - prod0: 489, - transitions: &[], - k: 0, - }, - /* 24 - "ArrayList" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 32, 1, 490), Trans(0, 45, 2, 491)], - k: 1, - }, - /* 25 - "ArrayLiteralItem" */ - LookaheadDFA { - prod0: 451, - transitions: &[], - k: 0, - }, - /* 26 - "ArrayLiteralItemGroup" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 6, 1, 452), - Trans(0, 7, 1, 452), - Trans(0, 8, 1, 452), - Trans(0, 9, 1, 452), - Trans(0, 10, 1, 452), - Trans(0, 11, 1, 452), - Trans(0, 18, 1, 452), - Trans(0, 24, 1, 452), - Trans(0, 25, 1, 452), - Trans(0, 26, 1, 452), - Trans(0, 27, 1, 452), - Trans(0, 39, 1, 452), - Trans(0, 40, 1, 452), - Trans(0, 42, 1, 452), - Trans(0, 54, 1, 452), - Trans(0, 58, 2, 453), - Trans(0, 71, 1, 452), - Trans(0, 77, 1, 452), - Trans(0, 84, 1, 452), - Trans(0, 87, 1, 452), - Trans(0, 89, 1, 452), - Trans(0, 106, 1, 452), - Trans(0, 114, 1, 452), - Trans(0, 115, 1, 452), - ], - k: 1, - }, - /* 27 - "ArrayLiteralItemOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 32, 2, 455), - Trans(0, 44, 2, 455), - Trans(0, 94, 1, 454), - ], - k: 1, - }, - /* 28 - "ArrayLiteralList" */ - LookaheadDFA { - prod0: 446, - transitions: &[], - k: 0, - }, - /* 29 - "ArrayLiteralListList" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 32, 1, -1), - Trans(0, 44, 11, -1), - Trans(1, 5, 10, -1), - Trans(1, 6, 2, -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, 18, 4, -1), - Trans(1, 24, 4, -1), - Trans(1, 25, 4, -1), - Trans(1, 26, 4, -1), - Trans(1, 27, 4, -1), - Trans(1, 39, 5, -1), - Trans(1, 40, 4, -1), - Trans(1, 42, 4, -1), - Trans(1, 44, 25, -1), - Trans(1, 54, 4, -1), - Trans(1, 58, 6, -1), - Trans(1, 71, 4, -1), - Trans(1, 77, 4, -1), - Trans(1, 84, 2, -1), - Trans(1, 87, 2, -1), - Trans(1, 89, 4, -1), - Trans(1, 106, 7, -1), - Trans(1, 114, 8, -1), - Trans(1, 115, 9, -1), - Trans(2, 5, 3, 447), - Trans(2, 16, 3, 447), - Trans(2, 17, 3, 447), - Trans(2, 18, 3, 447), - Trans(2, 19, 3, 447), - Trans(2, 20, 3, 447), - Trans(2, 21, 3, 447), - Trans(2, 22, 3, 447), - Trans(2, 23, 3, 447), - Trans(2, 24, 3, 447), - Trans(2, 25, 3, 447), - Trans(2, 26, 3, 447), - Trans(2, 32, 3, 447), - Trans(2, 44, 3, 447), - Trans(2, 48, 3, 447), - Trans(2, 52, 3, 447), - Trans(2, 94, 3, 447), - Trans(4, 5, 3, 447), - Trans(4, 6, 3, 447), - Trans(4, 7, 3, 447), - Trans(4, 8, 3, 447), - Trans(4, 9, 3, 447), - Trans(4, 10, 3, 447), - Trans(4, 11, 3, 447), - Trans(4, 18, 3, 447), - Trans(4, 24, 3, 447), - Trans(4, 25, 3, 447), - Trans(4, 26, 3, 447), - Trans(4, 27, 3, 447), - Trans(4, 39, 3, 447), - Trans(4, 40, 3, 447), - Trans(4, 42, 3, 447), - Trans(4, 54, 3, 447), - Trans(4, 71, 3, 447), - Trans(4, 77, 3, 447), - Trans(4, 84, 3, 447), - Trans(4, 87, 3, 447), - Trans(4, 89, 3, 447), - Trans(4, 106, 3, 447), - Trans(4, 114, 3, 447), - Trans(4, 115, 3, 447), - Trans(5, 5, 3, 447), - Trans(5, 6, 3, 447), - Trans(5, 7, 3, 447), - Trans(5, 8, 3, 447), - Trans(5, 9, 3, 447), - Trans(5, 10, 3, 447), - Trans(5, 11, 3, 447), - Trans(5, 18, 3, 447), - Trans(5, 24, 3, 447), - Trans(5, 25, 3, 447), - Trans(5, 26, 3, 447), - Trans(5, 27, 3, 447), - Trans(5, 39, 3, 447), - Trans(5, 40, 3, 447), - Trans(5, 42, 3, 447), - Trans(5, 54, 3, 447), - Trans(5, 58, 3, 447), - Trans(5, 71, 3, 447), - Trans(5, 77, 3, 447), - Trans(5, 84, 3, 447), - Trans(5, 87, 3, 447), - Trans(5, 89, 3, 447), - Trans(5, 106, 3, 447), - Trans(5, 114, 3, 447), - Trans(5, 115, 3, 447), - Trans(6, 5, 3, 447), - Trans(6, 31, 3, 447), - Trans(7, 5, 3, 447), - Trans(7, 40, 3, 447), - Trans(8, 5, 3, 447), - Trans(8, 16, 3, 447), - Trans(8, 17, 3, 447), - Trans(8, 18, 3, 447), - Trans(8, 19, 3, 447), - Trans(8, 20, 3, 447), - Trans(8, 21, 3, 447), - Trans(8, 22, 3, 447), - Trans(8, 23, 3, 447), - Trans(8, 24, 3, 447), - Trans(8, 25, 3, 447), - Trans(8, 26, 3, 447), - Trans(8, 30, 3, 447), - Trans(8, 32, 3, 447), - Trans(8, 35, 3, 447), - Trans(8, 41, 3, 447), - Trans(8, 42, 3, 447), - Trans(8, 44, 3, 447), - Trans(8, 48, 3, 447), - Trans(8, 52, 3, 447), - Trans(8, 94, 3, 447), - Trans(9, 5, 3, 447), - Trans(9, 16, 3, 447), - Trans(9, 17, 3, 447), - Trans(9, 18, 3, 447), - Trans(9, 19, 3, 447), - Trans(9, 20, 3, 447), - Trans(9, 21, 3, 447), - Trans(9, 22, 3, 447), - Trans(9, 23, 3, 447), - Trans(9, 24, 3, 447), - Trans(9, 25, 3, 447), - Trans(9, 26, 3, 447), - Trans(9, 29, 3, 447), - Trans(9, 30, 3, 447), - Trans(9, 32, 3, 447), - Trans(9, 35, 3, 447), - Trans(9, 41, 3, 447), - Trans(9, 42, 3, 447), - Trans(9, 44, 3, 447), - Trans(9, 48, 3, 447), - Trans(9, 52, 3, 447), - Trans(9, 94, 3, 447), - Trans(10, 6, 3, 447), - Trans(10, 7, 3, 447), - Trans(10, 8, 3, 447), - Trans(10, 9, 3, 447), - Trans(10, 10, 3, 447), - Trans(10, 11, 3, 447), - Trans(10, 18, 3, 447), - Trans(10, 24, 3, 447), - Trans(10, 25, 3, 447), - Trans(10, 26, 3, 447), - Trans(10, 27, 3, 447), - Trans(10, 39, 3, 447), - Trans(10, 40, 3, 447), - Trans(10, 42, 3, 447), - Trans(10, 44, 24, 448), - Trans(10, 54, 3, 447), - Trans(10, 58, 3, 447), - Trans(10, 71, 3, 447), - Trans(10, 77, 3, 447), - Trans(10, 84, 3, 447), - Trans(10, 87, 3, 447), - Trans(10, 89, 3, 447), - Trans(10, 106, 3, 447), - Trans(10, 114, 3, 447), - Trans(10, 115, 3, 447), - Trans(11, 5, 12, -1), - Trans(11, 12, 13, -1), - Trans(11, 14, 13, -1), - Trans(11, 16, 13, -1), - Trans(11, 17, 13, -1), - Trans(11, 18, 13, -1), - Trans(11, 19, 13, -1), - Trans(11, 20, 13, -1), - Trans(11, 21, 13, -1), - Trans(11, 22, 13, -1), - Trans(11, 23, 13, -1), - Trans(11, 24, 13, -1), - Trans(11, 25, 13, -1), - Trans(11, 26, 13, -1), - Trans(11, 31, 14, -1), - Trans(11, 32, 15, -1), - Trans(11, 33, 13, -1), - Trans(11, 34, 13, -1), - Trans(11, 40, 16, -1), - Trans(11, 43, 17, -1), - Trans(11, 44, 18, -1), - Trans(11, 45, 19, -1), - Trans(11, 46, 20, -1), - Trans(11, 47, 21, -1), - Trans(11, 48, 13, -1), - Trans(11, 52, 22, -1), - Trans(11, 94, 13, -1), - Trans(11, 103, 23, -1), - Trans(12, 12, 24, 448), - Trans(12, 14, 24, 448), - Trans(12, 16, 24, 448), - Trans(12, 17, 24, 448), - Trans(12, 18, 24, 448), - Trans(12, 19, 24, 448), - Trans(12, 20, 24, 448), - Trans(12, 21, 24, 448), - Trans(12, 22, 24, 448), - Trans(12, 23, 24, 448), - Trans(12, 24, 24, 448), - Trans(12, 25, 24, 448), - Trans(12, 26, 24, 448), - Trans(12, 31, 24, 448), - Trans(12, 32, 24, 448), - Trans(12, 33, 24, 448), - Trans(12, 34, 24, 448), - Trans(12, 40, 24, 448), - Trans(12, 43, 24, 448), - Trans(12, 44, 24, 448), - Trans(12, 45, 24, 448), - Trans(12, 46, 24, 448), - Trans(12, 47, 24, 448), - Trans(12, 48, 24, 448), - Trans(12, 52, 24, 448), - Trans(12, 94, 24, 448), - Trans(12, 103, 24, 448), - Trans(13, 5, 24, 448), - Trans(13, 6, 24, 448), - Trans(13, 7, 24, 448), - Trans(13, 8, 24, 448), - Trans(13, 9, 24, 448), - Trans(13, 10, 24, 448), - Trans(13, 11, 24, 448), - Trans(13, 18, 24, 448), - Trans(13, 24, 24, 448), - Trans(13, 25, 24, 448), - Trans(13, 26, 24, 448), - Trans(13, 27, 24, 448), - Trans(13, 39, 24, 448), - Trans(13, 40, 24, 448), - Trans(13, 42, 24, 448), - Trans(13, 54, 24, 448), - Trans(13, 71, 24, 448), - Trans(13, 77, 24, 448), - Trans(13, 84, 24, 448), - Trans(13, 87, 24, 448), - Trans(13, 89, 24, 448), - Trans(13, 106, 24, 448), - Trans(13, 114, 24, 448), - Trans(13, 115, 24, 448), - Trans(14, 5, 24, 448), - Trans(14, 6, 24, 448), - Trans(14, 7, 24, 448), - Trans(14, 8, 24, 448), - Trans(14, 9, 24, 448), - Trans(14, 10, 24, 448), - Trans(14, 11, 24, 448), - Trans(14, 18, 24, 448), - Trans(14, 24, 24, 448), - Trans(14, 25, 24, 448), - Trans(14, 26, 24, 448), - Trans(14, 27, 24, 448), - Trans(14, 39, 24, 448), - Trans(14, 40, 24, 448), - Trans(14, 42, 24, 448), - Trans(14, 54, 24, 448), - Trans(14, 66, 24, 448), - Trans(14, 70, 24, 448), - Trans(14, 71, 24, 448), - Trans(14, 77, 24, 448), - Trans(14, 81, 24, 448), - Trans(14, 84, 24, 448), - Trans(14, 87, 24, 448), - Trans(14, 89, 24, 448), - Trans(14, 100, 24, 448), - Trans(14, 101, 24, 448), - Trans(14, 106, 24, 448), - Trans(14, 114, 24, 448), - Trans(14, 115, 24, 448), - Trans(15, 5, 24, 448), - Trans(15, 6, 24, 448), - Trans(15, 7, 24, 448), - Trans(15, 8, 24, 448), - Trans(15, 9, 24, 448), - Trans(15, 10, 24, 448), - Trans(15, 11, 24, 448), - Trans(15, 18, 24, 448), - Trans(15, 24, 24, 448), - Trans(15, 25, 24, 448), - Trans(15, 26, 24, 448), - Trans(15, 27, 24, 448), - Trans(15, 37, 24, 448), - Trans(15, 39, 24, 448), - Trans(15, 40, 24, 448), - Trans(15, 42, 24, 448), - Trans(15, 44, 24, 448), - Trans(15, 46, 24, 448), - Trans(15, 54, 24, 448), - Trans(15, 58, 24, 448), - Trans(15, 71, 24, 448), - Trans(15, 77, 24, 448), - Trans(15, 82, 24, 448), - Trans(15, 84, 24, 448), - Trans(15, 87, 24, 448), - Trans(15, 89, 24, 448), - Trans(15, 91, 24, 448), - Trans(15, 106, 24, 448), - Trans(15, 114, 24, 448), - Trans(15, 115, 24, 448), - Trans(16, 5, 24, 448), - Trans(16, 6, 24, 448), - Trans(16, 7, 24, 448), - Trans(16, 8, 24, 448), - Trans(16, 9, 24, 448), - Trans(16, 10, 24, 448), - Trans(16, 11, 24, 448), - Trans(16, 18, 24, 448), - Trans(16, 24, 24, 448), - Trans(16, 25, 24, 448), - Trans(16, 26, 24, 448), - Trans(16, 27, 24, 448), - Trans(16, 31, 24, 448), - Trans(16, 37, 24, 448), - Trans(16, 39, 24, 448), - Trans(16, 40, 24, 448), - Trans(16, 42, 24, 448), - Trans(16, 44, 24, 448), - Trans(16, 49, 24, 448), - Trans(16, 50, 24, 448), - Trans(16, 51, 24, 448), - Trans(16, 54, 24, 448), - Trans(16, 58, 24, 448), - Trans(16, 61, 24, 448), - Trans(16, 65, 24, 448), - Trans(16, 66, 24, 448), - Trans(16, 67, 24, 448), - Trans(16, 70, 24, 448), - Trans(16, 71, 24, 448), - Trans(16, 72, 24, 448), - Trans(16, 74, 24, 448), - Trans(16, 77, 24, 448), - Trans(16, 78, 24, 448), - Trans(16, 81, 24, 448), - Trans(16, 82, 24, 448), - Trans(16, 84, 24, 448), - Trans(16, 85, 24, 448), - Trans(16, 87, 24, 448), - Trans(16, 89, 24, 448), - Trans(16, 100, 24, 448), - Trans(16, 101, 24, 448), - Trans(16, 105, 24, 448), - Trans(16, 106, 24, 448), - Trans(16, 108, 24, 448), - Trans(16, 111, 24, 448), - Trans(16, 112, 24, 448), - Trans(16, 113, 24, 448), - Trans(16, 114, 24, 448), - Trans(16, 115, 24, 448), - Trans(17, 5, 24, 448), - Trans(17, 32, 24, 448), - Trans(17, 36, 24, 448), - Trans(17, 40, 24, 448), - Trans(17, 41, 24, 448), - Trans(17, 44, 24, 448), - Trans(17, 46, 24, 448), - Trans(17, 47, 24, 448), - Trans(17, 80, 24, 448), - Trans(18, 5, 24, 448), - Trans(18, 12, 24, 448), - Trans(18, 14, 24, 448), - Trans(18, 16, 24, 448), - Trans(18, 17, 24, 448), - Trans(18, 18, 24, 448), - Trans(18, 19, 24, 448), - Trans(18, 20, 24, 448), - Trans(18, 21, 24, 448), - Trans(18, 22, 24, 448), - Trans(18, 23, 24, 448), - Trans(18, 24, 24, 448), - Trans(18, 25, 24, 448), - Trans(18, 26, 24, 448), - Trans(18, 31, 24, 448), - Trans(18, 32, 24, 448), - Trans(18, 33, 24, 448), - Trans(18, 34, 24, 448), - Trans(18, 37, 24, 448), - Trans(18, 40, 24, 448), - Trans(18, 43, 24, 448), - Trans(18, 44, 24, 448), - Trans(18, 45, 24, 448), - Trans(18, 46, 24, 448), - Trans(18, 47, 24, 448), - Trans(18, 48, 24, 448), - Trans(18, 49, 24, 448), - Trans(18, 50, 24, 448), - Trans(18, 51, 24, 448), - Trans(18, 52, 24, 448), - Trans(18, 59, 24, 448), - Trans(18, 61, 24, 448), - Trans(18, 62, 24, 448), - Trans(18, 65, 24, 448), - Trans(18, 66, 24, 448), - Trans(18, 67, 24, 448), - Trans(18, 71, 24, 448), - Trans(18, 72, 24, 448), - Trans(18, 74, 24, 448), - Trans(18, 78, 24, 448), - Trans(18, 81, 24, 448), - Trans(18, 82, 24, 448), - Trans(18, 85, 24, 448), - Trans(18, 94, 24, 448), - Trans(18, 103, 24, 448), - Trans(18, 105, 24, 448), - Trans(18, 108, 24, 448), - Trans(18, 111, 24, 448), - Trans(18, 112, 24, 448), - Trans(18, 113, 24, 448), - Trans(19, 5, 24, 448), - Trans(19, 12, 24, 448), - Trans(19, 14, 24, 448), - Trans(19, 15, 24, 448), - Trans(19, 16, 24, 448), - Trans(19, 17, 24, 448), - Trans(19, 18, 24, 448), - Trans(19, 19, 24, 448), - Trans(19, 20, 24, 448), - Trans(19, 21, 24, 448), - Trans(19, 22, 24, 448), - Trans(19, 23, 24, 448), - Trans(19, 24, 24, 448), - Trans(19, 25, 24, 448), - Trans(19, 26, 24, 448), - Trans(19, 31, 24, 448), - Trans(19, 32, 24, 448), - Trans(19, 33, 24, 448), - Trans(19, 34, 24, 448), - Trans(19, 35, 24, 448), - Trans(19, 36, 24, 448), - Trans(19, 37, 24, 448), - Trans(19, 40, 24, 448), - Trans(19, 41, 24, 448), - Trans(19, 42, 24, 448), - Trans(19, 43, 24, 448), - Trans(19, 44, 24, 448), - Trans(19, 45, 24, 448), - Trans(19, 46, 24, 448), - Trans(19, 47, 24, 448), - Trans(19, 48, 24, 448), - Trans(19, 52, 24, 448), - Trans(19, 94, 24, 448), - Trans(19, 103, 24, 448), - Trans(20, 5, 24, 448), - Trans(20, 12, 24, 448), - Trans(20, 14, 24, 448), - Trans(20, 16, 24, 448), - Trans(20, 17, 24, 448), - Trans(20, 18, 24, 448), - Trans(20, 19, 24, 448), - Trans(20, 20, 24, 448), - Trans(20, 21, 24, 448), - Trans(20, 22, 24, 448), - Trans(20, 23, 24, 448), - Trans(20, 24, 24, 448), - Trans(20, 25, 24, 448), - Trans(20, 26, 24, 448), - Trans(20, 31, 24, 448), - Trans(20, 32, 24, 448), - Trans(20, 33, 24, 448), - Trans(20, 34, 24, 448), - Trans(20, 40, 24, 448), - Trans(20, 42, 24, 448), - Trans(20, 43, 24, 448), - Trans(20, 44, 24, 448), - Trans(20, 45, 24, 448), - Trans(20, 46, 24, 448), - Trans(20, 47, 24, 448), - Trans(20, 48, 24, 448), - Trans(20, 52, 24, 448), - Trans(20, 94, 24, 448), - Trans(20, 103, 24, 448), - Trans(21, 5, 24, 448), - Trans(21, 6, 24, 448), - Trans(21, 7, 24, 448), - Trans(21, 8, 24, 448), - Trans(21, 9, 24, 448), - Trans(21, 10, 24, 448), - Trans(21, 11, 24, 448), - Trans(21, 18, 24, 448), - Trans(21, 24, 24, 448), - Trans(21, 25, 24, 448), - Trans(21, 26, 24, 448), - Trans(21, 27, 24, 448), - Trans(21, 31, 24, 448), - Trans(21, 37, 24, 448), - Trans(21, 39, 24, 448), - Trans(21, 40, 24, 448), - Trans(21, 42, 24, 448), - Trans(21, 44, 24, 448), - Trans(21, 49, 24, 448), - Trans(21, 50, 24, 448), - Trans(21, 51, 24, 448), - Trans(21, 54, 24, 448), - Trans(21, 58, 24, 448), - Trans(21, 61, 24, 448), - Trans(21, 62, 24, 448), - Trans(21, 65, 24, 448), - Trans(21, 66, 24, 448), - Trans(21, 67, 24, 448), - Trans(21, 70, 24, 448), - Trans(21, 71, 24, 448), - Trans(21, 72, 24, 448), - Trans(21, 74, 24, 448), - Trans(21, 77, 24, 448), - Trans(21, 78, 24, 448), - Trans(21, 81, 24, 448), - Trans(21, 82, 24, 448), - Trans(21, 84, 24, 448), - Trans(21, 85, 24, 448), - Trans(21, 87, 24, 448), - Trans(21, 89, 24, 448), - Trans(21, 100, 24, 448), - Trans(21, 101, 24, 448), - Trans(21, 105, 24, 448), - Trans(21, 106, 24, 448), - Trans(21, 108, 24, 448), - Trans(21, 111, 24, 448), - Trans(21, 112, 24, 448), - Trans(21, 113, 24, 448), - Trans(21, 114, 24, 448), - Trans(21, 115, 24, 448), - Trans(22, 5, 24, 448), - Trans(22, 55, 24, 448), - Trans(22, 56, 24, 448), - Trans(22, 57, 24, 448), - Trans(22, 63, 24, 448), - Trans(22, 64, 24, 448), - Trans(22, 68, 24, 448), - Trans(22, 69, 24, 448), - Trans(22, 95, 24, 448), - Trans(22, 96, 24, 448), - Trans(22, 97, 24, 448), - Trans(22, 98, 24, 448), - Trans(22, 99, 24, 448), - Trans(22, 109, 24, 448), - Trans(22, 110, 24, 448), - Trans(22, 114, 24, 448), - Trans(22, 115, 24, 448), - Trans(23, 5, 24, 448), - Trans(23, 6, 24, 448), - Trans(23, 7, 24, 448), - Trans(23, 8, 24, 448), - Trans(23, 9, 24, 448), - Trans(23, 10, 24, 448), - Trans(23, 11, 24, 448), - Trans(23, 15, 24, 448), - Trans(23, 18, 24, 448), - Trans(23, 24, 24, 448), - Trans(23, 25, 24, 448), - Trans(23, 26, 24, 448), - Trans(23, 27, 24, 448), - Trans(23, 39, 24, 448), - Trans(23, 40, 24, 448), - Trans(23, 42, 24, 448), - Trans(23, 54, 24, 448), - Trans(23, 71, 24, 448), - Trans(23, 77, 24, 448), - Trans(23, 84, 24, 448), - Trans(23, 87, 24, 448), - Trans(23, 89, 24, 448), - Trans(23, 106, 24, 448), - Trans(23, 114, 24, 448), - Trans(23, 115, 24, 448), - Trans(25, 5, 24, 448), - Trans(25, 12, 24, 448), - Trans(25, 14, 24, 448), - Trans(25, 16, 24, 448), - Trans(25, 17, 24, 448), - Trans(25, 18, 24, 448), - Trans(25, 19, 24, 448), - Trans(25, 20, 24, 448), - Trans(25, 21, 24, 448), - Trans(25, 22, 24, 448), - Trans(25, 23, 24, 448), - Trans(25, 24, 24, 448), - Trans(25, 25, 24, 448), - Trans(25, 26, 24, 448), - Trans(25, 31, 24, 448), - Trans(25, 32, 24, 448), - Trans(25, 33, 24, 448), - Trans(25, 34, 24, 448), - Trans(25, 40, 24, 448), - Trans(25, 43, 24, 448), - Trans(25, 44, 24, 448), - Trans(25, 45, 24, 448), - Trans(25, 46, 24, 448), - Trans(25, 47, 24, 448), - Trans(25, 48, 24, 448), - Trans(25, 52, 24, 448), - Trans(25, 94, 24, 448), - Trans(25, 103, 24, 448), - ], - k: 3, - }, - /* 30 - "ArrayLiteralListOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 32, 1, 449), Trans(0, 44, 2, 450)], - k: 1, - }, - /* 31 - "ArrayType" */ - LookaheadDFA { - prod0: 525, - transitions: &[], - k: 0, - }, - /* 32 - "ArrayTypeOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 32, 2, 527), - Trans(0, 36, 2, 527), - Trans(0, 41, 1, 526), - Trans(0, 44, 2, 527), - Trans(0, 46, 2, 527), - Trans(0, 47, 2, 527), - ], - k: 1, - }, - /* 33 - "As" */ - LookaheadDFA { - prod0: 272, - transitions: &[], - k: 0, - }, - /* 34 - "AsTerm" */ - LookaheadDFA { - prod0: 47, - transitions: &[], - k: 0, - }, - /* 35 - "AsToken" */ - LookaheadDFA { - prod0: 161, - transitions: &[], - k: 0, - }, - /* 36 - "Assign" */ - LookaheadDFA { - prod0: 273, - transitions: &[], - k: 0, - }, - /* 37 - "AssignDeclaration" */ - LookaheadDFA { - prod0: 650, - transitions: &[], - k: 0, - }, - /* 38 - "AssignTerm" */ - LookaheadDFA { - prod0: 46, - transitions: &[], - k: 0, - }, - /* 39 - "AssignToken" */ - LookaheadDFA { - prod0: 162, - transitions: &[], - k: 0, - }, - /* 40 - "Assignment" */ - LookaheadDFA { - prod0: 559, - transitions: &[], - k: 0, - }, - /* 41 - "AssignmentGroup" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 15, 2, 561), Trans(0, 36, 1, 560)], - k: 1, - }, - /* 42 - "AssignmentOperator" */ - LookaheadDFA { - prod0: 233, - transitions: &[], - k: 0, - }, - /* 43 - "AssignmentOperatorTerm" */ - LookaheadDFA { - prod0: 10, - transitions: &[], - k: 0, - }, - /* 44 - "AssignmentOperatorToken" */ - LookaheadDFA { - prod0: 122, - transitions: &[], - k: 0, - }, - /* 45 - "Attribute" */ - LookaheadDFA { - prod0: 617, - transitions: &[], - k: 0, - }, - /* 46 - "AttributeItem" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 6, 2, 626), Trans(0, 115, 1, 625)], - k: 1, - }, - /* 47 - "AttributeList" */ - LookaheadDFA { - prod0: 620, - transitions: &[], - k: 0, - }, - /* 48 - "AttributeListList" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 32, 1, -1), - Trans(0, 46, 5, -1), - Trans(1, 5, 4, -1), - Trans(1, 6, 2, -1), - Trans(1, 46, 9, -1), - Trans(1, 115, 2, -1), - Trans(2, 5, 3, 621), - Trans(2, 32, 3, 621), - Trans(2, 46, 3, 621), - Trans(4, 6, 3, 621), - Trans(4, 46, 8, 622), - Trans(4, 115, 3, 621), - Trans(5, 5, 6, -1), - Trans(5, 45, 7, -1), - Trans(6, 45, 8, 622), - Trans(7, 5, 8, 622), - Trans(7, 31, 8, 622), - Trans(7, 37, 8, 622), - Trans(7, 40, 8, 622), - Trans(7, 49, 8, 622), - Trans(7, 50, 8, 622), - Trans(7, 51, 8, 622), - Trans(7, 60, 8, 622), - Trans(7, 61, 8, 622), - Trans(7, 62, 8, 622), - Trans(7, 65, 8, 622), - Trans(7, 66, 8, 622), - Trans(7, 67, 8, 622), - Trans(7, 71, 8, 622), - Trans(7, 72, 8, 622), - Trans(7, 73, 8, 622), - Trans(7, 74, 8, 622), - Trans(7, 78, 8, 622), - Trans(7, 79, 8, 622), - Trans(7, 81, 8, 622), - Trans(7, 82, 8, 622), - Trans(7, 85, 8, 622), - Trans(7, 86, 8, 622), - Trans(7, 90, 8, 622), - Trans(7, 91, 8, 622), - Trans(7, 92, 8, 622), - Trans(7, 105, 8, 622), - Trans(7, 108, 8, 622), - Trans(7, 111, 8, 622), - Trans(7, 112, 8, 622), - Trans(7, 113, 8, 622), - Trans(7, 115, 8, 622), - Trans(9, 5, 8, 622), - Trans(9, 45, 8, 622), - ], - k: 3, - }, - /* 49 - "AttributeListOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 32, 1, 623), Trans(0, 46, 2, 624)], - k: 1, - }, - /* 50 - "AttributeOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 42, 1, 618), Trans(0, 45, 2, 619)], - k: 1, - }, - /* 51 - "BackQuote" */ - LookaheadDFA { - prod0: 246, - transitions: &[], - k: 0, - }, - /* 52 - "BackQuoteTerm" */ - LookaheadDFA { - prod0: 23, - transitions: &[], - k: 0, - }, - /* 53 - "BackQuoteToken" */ - LookaheadDFA { - prod0: 135, - transitions: &[], - k: 0, - }, - /* 54 - "BaseLess" */ - LookaheadDFA { - prod0: 231, - transitions: &[], - k: 0, - }, - /* 55 - "BaseLessTerm" */ - LookaheadDFA { - prod0: 6, - transitions: &[], - k: 0, - }, - /* 56 - "BaseLessToken" */ - LookaheadDFA { - prod0: 120, - transitions: &[], - k: 0, - }, - /* 57 - "Based" */ - LookaheadDFA { - prod0: 230, - transitions: &[], - k: 0, - }, - /* 58 - "BasedTerm" */ - LookaheadDFA { - prod0: 4, - transitions: &[], - k: 0, - }, - /* 59 - "BasedToken" */ - LookaheadDFA { - prod0: 119, - transitions: &[], - k: 0, - }, - /* 60 - "Bit" */ - LookaheadDFA { - prod0: 274, - transitions: &[], - k: 0, - }, - /* 61 - "BitTerm" */ - LookaheadDFA { - prod0: 48, - transitions: &[], - k: 0, - }, - /* 62 - "BitToken" */ - LookaheadDFA { - prod0: 163, - transitions: &[], - k: 0, - }, - /* 63 - "Break" */ - LookaheadDFA { - prod0: 275, - transitions: &[], - k: 0, - }, - /* 64 - "BreakStatement" */ - LookaheadDFA { - prod0: 585, - transitions: &[], - k: 0, - }, - /* 65 - "BreakTerm" */ - LookaheadDFA { - prod0: 96, - transitions: &[], - k: 0, - }, - /* 66 - "BreakToken" */ - LookaheadDFA { - prod0: 211, - transitions: &[], - k: 0, - }, - /* 67 - "Case" */ - LookaheadDFA { - prod0: 276, - transitions: &[], - k: 0, - }, - /* 68 - "CaseCondition" */ - LookaheadDFA { - prod0: 601, - transitions: &[], - k: 0, - }, - /* 69 - "CaseConditionList" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 31, 2, 603), Trans(0, 32, 1, 602)], - k: 1, - }, - /* 70 - "CaseExpression" */ - LookaheadDFA { - prod0: 459, - transitions: &[], - k: 0, - }, - /* 71 - "CaseExpressionList" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 6, 1, 460), - Trans(0, 7, 1, 460), - Trans(0, 8, 1, 460), - Trans(0, 9, 1, 460), - Trans(0, 10, 1, 460), - Trans(0, 11, 1, 460), - Trans(0, 18, 1, 460), - Trans(0, 24, 1, 460), - Trans(0, 25, 1, 460), - Trans(0, 26, 1, 460), - Trans(0, 27, 1, 460), - Trans(0, 39, 1, 460), - Trans(0, 40, 1, 460), - Trans(0, 42, 1, 460), - Trans(0, 54, 1, 460), - Trans(0, 58, 2, 461), - Trans(0, 71, 1, 460), - Trans(0, 77, 1, 460), - Trans(0, 84, 1, 460), - Trans(0, 87, 1, 460), - Trans(0, 89, 1, 460), - Trans(0, 106, 1, 460), - Trans(0, 114, 1, 460), - Trans(0, 115, 1, 460), - ], - k: 1, - }, - /* 72 - "CaseExpressionOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 32, 1, 462), Trans(0, 44, 2, 463)], - k: 1, - }, - /* 73 - "CaseItem" */ - LookaheadDFA { - prod0: 594, - transitions: &[], - k: 0, - }, - /* 74 - "CaseItemGroup" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 6, 1, 599), - Trans(0, 7, 1, 599), - Trans(0, 8, 1, 599), - Trans(0, 9, 1, 599), - Trans(0, 10, 1, 599), - Trans(0, 11, 1, 599), - Trans(0, 18, 1, 599), - Trans(0, 24, 1, 599), - Trans(0, 25, 1, 599), - Trans(0, 26, 1, 599), - Trans(0, 27, 1, 599), - Trans(0, 39, 1, 599), - Trans(0, 40, 1, 599), - Trans(0, 42, 1, 599), - Trans(0, 54, 1, 599), - Trans(0, 58, 2, 600), - Trans(0, 71, 1, 599), - Trans(0, 77, 1, 599), - Trans(0, 84, 1, 599), - Trans(0, 87, 1, 599), - Trans(0, 89, 1, 599), - Trans(0, 106, 1, 599), - Trans(0, 114, 1, 599), - Trans(0, 115, 1, 599), - ], - k: 1, - }, - /* 75 - "CaseItemGroup0" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 40, 2, 596), - Trans(0, 54, 1, 595), - Trans(0, 66, 1, 595), - Trans(0, 70, 1, 595), - Trans(0, 71, 1, 595), - Trans(0, 81, 1, 595), - Trans(0, 100, 1, 595), - Trans(0, 101, 1, 595), - Trans(0, 106, 1, 595), - Trans(0, 114, 1, 595), - Trans(0, 115, 1, 595), - ], - k: 1, - }, - /* 76 - "CaseItemGroup0List" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 44, 2, 598), - Trans(0, 54, 1, 597), - Trans(0, 66, 1, 597), - Trans(0, 70, 1, 597), - Trans(0, 71, 1, 597), - Trans(0, 81, 1, 597), - Trans(0, 100, 1, 597), - Trans(0, 101, 1, 597), - Trans(0, 106, 1, 597), - Trans(0, 114, 1, 597), - Trans(0, 115, 1, 597), - ], - k: 1, - }, - /* 77 - "CaseStatement" */ - LookaheadDFA { - prod0: 591, - transitions: &[], - k: 0, - }, - /* 78 - "CaseStatementList" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 6, 1, 592), - Trans(0, 7, 1, 592), - Trans(0, 8, 1, 592), - Trans(0, 9, 1, 592), - Trans(0, 10, 1, 592), - Trans(0, 11, 1, 592), - Trans(0, 18, 1, 592), - Trans(0, 24, 1, 592), - Trans(0, 25, 1, 592), - Trans(0, 26, 1, 592), - Trans(0, 27, 1, 592), - Trans(0, 39, 1, 592), - Trans(0, 40, 1, 592), - Trans(0, 42, 1, 592), - Trans(0, 44, 2, 593), - Trans(0, 54, 1, 592), - Trans(0, 58, 1, 592), - Trans(0, 71, 1, 592), - Trans(0, 77, 1, 592), - Trans(0, 84, 1, 592), - Trans(0, 87, 1, 592), - Trans(0, 89, 1, 592), - Trans(0, 106, 1, 592), - Trans(0, 114, 1, 592), - Trans(0, 115, 1, 592), - ], - k: 1, - }, - /* 79 - "CaseTerm" */ - LookaheadDFA { - prod0: 49, - transitions: &[], - k: 0, - }, - /* 80 - "CaseToken" */ - LookaheadDFA { - prod0: 164, - transitions: &[], - k: 0, - }, - /* 81 - "CastingType" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 55, 7, 534), - Trans(0, 56, 8, 535), - Trans(0, 57, 9, 536), - Trans(0, 63, 5, 532), - Trans(0, 64, 6, 533), - Trans(0, 68, 3, 530), - Trans(0, 69, 4, 531), - Trans(0, 95, 10, 537), - Trans(0, 96, 11, 538), - Trans(0, 97, 12, 539), - Trans(0, 98, 13, 540), - Trans(0, 99, 14, 541), - Trans(0, 109, 1, 528), - Trans(0, 110, 2, 529), - Trans(0, 114, 15, 542), - Trans(0, 115, 15, 542), - ], - k: 1, - }, - /* 82 - "Clock" */ - LookaheadDFA { - prod0: 277, - transitions: &[], - k: 0, - }, - /* 83 - "ClockDomain" */ - LookaheadDFA { - prod0: 543, - transitions: &[], - k: 0, - }, - /* 84 - "ClockNegedge" */ - LookaheadDFA { - prod0: 279, - transitions: &[], - k: 0, - }, - /* 85 - "ClockNegedgeTerm" */ - LookaheadDFA { - prod0: 52, - transitions: &[], - k: 0, - }, - /* 86 - "ClockNegedgeToken" */ - LookaheadDFA { - prod0: 167, - transitions: &[], - k: 0, - }, - /* 87 - "ClockPosedge" */ - LookaheadDFA { - prod0: 278, - transitions: &[], - k: 0, - }, - /* 88 - "ClockPosedgeTerm" */ - LookaheadDFA { - prod0: 51, - transitions: &[], - k: 0, - }, - /* 89 - "ClockPosedgeToken" */ - LookaheadDFA { - prod0: 166, - transitions: &[], - k: 0, - }, - /* 90 - "ClockTerm" */ - LookaheadDFA { - prod0: 50, - transitions: &[], - k: 0, - }, - /* 91 - "ClockToken" */ - LookaheadDFA { - prod0: 165, - transitions: &[], - k: 0, - }, - /* 92 - "Colon" */ - LookaheadDFA { - prod0: 247, - transitions: &[], - k: 0, - }, - /* 93 - "ColonColon" */ - LookaheadDFA { - prod0: 249, - transitions: &[], - k: 0, - }, - /* 94 - "ColonColonLAngle" */ - LookaheadDFA { - prod0: 248, - transitions: &[], - k: 0, - }, - /* 95 - "ColonColonLAngleTerm" */ - LookaheadDFA { - prod0: 24, - transitions: &[], - k: 0, - }, - /* 96 - "ColonColonLAngleToken" */ - LookaheadDFA { - prod0: 137, - transitions: &[], - k: 0, - }, - /* 97 - "ColonColonTerm" */ - LookaheadDFA { - prod0: 25, - transitions: &[], - k: 0, - }, - /* 98 - "ColonColonToken" */ - LookaheadDFA { - prod0: 138, - transitions: &[], - k: 0, - }, - /* 99 - "ColonTerm" */ - LookaheadDFA { - prod0: 26, - transitions: &[], - k: 0, - }, - /* 100 - "ColonToken" */ - LookaheadDFA { - prod0: 136, - transitions: &[], - k: 0, - }, - /* 101 - "Comma" */ - LookaheadDFA { - prod0: 250, - transitions: &[], - k: 0, - }, - /* 102 - "CommaTerm" */ - LookaheadDFA { - prod0: 27, - transitions: &[], - k: 0, - }, - /* 103 - "CommaToken" */ - LookaheadDFA { - prod0: 139, - transitions: &[], - k: 0, - }, - /* 104 - "Comments" */ - LookaheadDFA { - prod0: 112, - transitions: &[], - k: 0, - }, - /* 105 - "CommentsOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 0, 2, 114), - Trans(0, 5, 1, 113), - Trans(0, 6, 2, 114), - Trans(0, 7, 2, 114), - Trans(0, 8, 2, 114), - Trans(0, 9, 2, 114), - Trans(0, 10, 2, 114), - Trans(0, 11, 2, 114), - Trans(0, 12, 2, 114), - Trans(0, 13, 2, 114), - Trans(0, 14, 2, 114), - Trans(0, 15, 2, 114), - Trans(0, 16, 2, 114), - Trans(0, 17, 2, 114), - Trans(0, 18, 2, 114), - Trans(0, 19, 2, 114), - Trans(0, 20, 2, 114), - Trans(0, 21, 2, 114), - Trans(0, 22, 2, 114), - Trans(0, 23, 2, 114), - Trans(0, 24, 2, 114), - Trans(0, 25, 2, 114), - Trans(0, 26, 2, 114), - Trans(0, 27, 2, 114), - Trans(0, 28, 2, 114), - Trans(0, 29, 2, 114), - Trans(0, 30, 2, 114), - Trans(0, 31, 2, 114), - Trans(0, 32, 2, 114), - Trans(0, 33, 2, 114), - Trans(0, 34, 2, 114), - Trans(0, 35, 2, 114), - Trans(0, 36, 2, 114), - Trans(0, 37, 2, 114), - Trans(0, 38, 2, 114), - Trans(0, 39, 2, 114), - Trans(0, 40, 2, 114), - Trans(0, 41, 2, 114), - Trans(0, 42, 2, 114), - Trans(0, 43, 2, 114), - Trans(0, 44, 2, 114), - Trans(0, 45, 2, 114), - Trans(0, 46, 2, 114), - Trans(0, 47, 2, 114), - Trans(0, 48, 2, 114), - Trans(0, 49, 2, 114), - Trans(0, 50, 2, 114), - Trans(0, 51, 2, 114), - Trans(0, 52, 2, 114), - Trans(0, 53, 2, 114), - Trans(0, 54, 2, 114), - Trans(0, 55, 2, 114), - Trans(0, 56, 2, 114), - Trans(0, 57, 2, 114), - Trans(0, 58, 2, 114), - Trans(0, 59, 2, 114), - Trans(0, 60, 2, 114), - Trans(0, 61, 2, 114), - Trans(0, 62, 2, 114), - Trans(0, 63, 2, 114), - Trans(0, 64, 2, 114), - Trans(0, 65, 2, 114), - Trans(0, 66, 2, 114), - Trans(0, 67, 2, 114), - Trans(0, 68, 2, 114), - Trans(0, 69, 2, 114), - Trans(0, 70, 2, 114), - Trans(0, 71, 2, 114), - Trans(0, 72, 2, 114), - Trans(0, 73, 2, 114), - Trans(0, 74, 2, 114), - Trans(0, 75, 2, 114), - Trans(0, 76, 2, 114), - Trans(0, 77, 2, 114), - Trans(0, 78, 2, 114), - Trans(0, 79, 2, 114), - Trans(0, 80, 2, 114), - Trans(0, 81, 2, 114), - Trans(0, 82, 2, 114), - Trans(0, 83, 2, 114), - Trans(0, 84, 2, 114), - Trans(0, 85, 2, 114), - Trans(0, 86, 2, 114), - Trans(0, 87, 2, 114), - Trans(0, 88, 2, 114), - Trans(0, 89, 2, 114), - Trans(0, 90, 2, 114), - Trans(0, 91, 2, 114), - Trans(0, 92, 2, 114), - Trans(0, 93, 2, 114), - Trans(0, 94, 2, 114), - Trans(0, 95, 2, 114), - Trans(0, 96, 2, 114), - Trans(0, 97, 2, 114), - Trans(0, 98, 2, 114), - Trans(0, 99, 2, 114), - Trans(0, 100, 2, 114), - Trans(0, 101, 2, 114), - Trans(0, 102, 2, 114), - Trans(0, 103, 2, 114), - Trans(0, 104, 2, 114), - Trans(0, 105, 2, 114), - Trans(0, 106, 2, 114), - Trans(0, 107, 2, 114), - Trans(0, 108, 2, 114), - Trans(0, 109, 2, 114), - Trans(0, 110, 2, 114), - Trans(0, 111, 2, 114), - Trans(0, 112, 2, 114), - Trans(0, 113, 2, 114), - Trans(0, 114, 2, 114), - Trans(0, 115, 2, 114), - ], - k: 1, - }, - /* 106 - "CommentsTerm" */ - LookaheadDFA { - prod0: 0, - transitions: &[], - k: 0, - }, - /* 107 - "ConcatenationItem" */ - LookaheadDFA { - prod0: 443, - transitions: &[], - k: 0, - }, - /* 108 - "ConcatenationItemOpt" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 32, 2, 445), - Trans(0, 44, 2, 445), - Trans(0, 94, 1, 444), - ], - k: 1, - }, - /* 109 - "ConcatenationList" */ - LookaheadDFA { - prod0: 438, - transitions: &[], - k: 0, - }, - /* 110 - "ConcatenationListList" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 32, 1, -1), - Trans(0, 44, 10, -1), - Trans(1, 5, 9, -1), - Trans(1, 6, 2, -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, 18, 4, -1), - Trans(1, 24, 4, -1), - Trans(1, 25, 4, -1), - Trans(1, 26, 4, -1), - Trans(1, 27, 4, -1), - Trans(1, 39, 5, -1), - Trans(1, 40, 4, -1), - Trans(1, 42, 4, -1), - Trans(1, 44, 24, -1), - Trans(1, 54, 4, -1), - Trans(1, 71, 4, -1), - Trans(1, 77, 4, -1), - Trans(1, 84, 2, -1), - Trans(1, 87, 2, -1), - Trans(1, 89, 4, -1), - Trans(1, 106, 6, -1), - Trans(1, 114, 7, -1), - Trans(1, 115, 8, -1), - Trans(2, 5, 3, 439), - Trans(2, 16, 3, 439), - Trans(2, 17, 3, 439), - Trans(2, 18, 3, 439), - Trans(2, 19, 3, 439), - Trans(2, 20, 3, 439), - Trans(2, 21, 3, 439), - Trans(2, 22, 3, 439), - Trans(2, 23, 3, 439), - Trans(2, 24, 3, 439), - Trans(2, 25, 3, 439), - Trans(2, 26, 3, 439), - Trans(2, 32, 3, 439), - Trans(2, 44, 3, 439), - Trans(2, 48, 3, 439), - Trans(2, 52, 3, 439), - Trans(2, 94, 3, 439), - Trans(4, 5, 3, 439), - Trans(4, 6, 3, 439), - Trans(4, 7, 3, 439), - Trans(4, 8, 3, 439), - Trans(4, 9, 3, 439), - Trans(4, 10, 3, 439), - Trans(4, 11, 3, 439), - Trans(4, 18, 3, 439), - Trans(4, 24, 3, 439), - Trans(4, 25, 3, 439), - Trans(4, 26, 3, 439), - Trans(4, 27, 3, 439), - Trans(4, 39, 3, 439), - Trans(4, 40, 3, 439), - Trans(4, 42, 3, 439), - Trans(4, 54, 3, 439), - Trans(4, 71, 3, 439), - Trans(4, 77, 3, 439), - Trans(4, 84, 3, 439), - Trans(4, 87, 3, 439), - Trans(4, 89, 3, 439), - Trans(4, 106, 3, 439), - Trans(4, 114, 3, 439), - Trans(4, 115, 3, 439), - Trans(5, 5, 3, 439), - Trans(5, 6, 3, 439), - Trans(5, 7, 3, 439), - Trans(5, 8, 3, 439), - Trans(5, 9, 3, 439), - Trans(5, 10, 3, 439), - Trans(5, 11, 3, 439), - Trans(5, 18, 3, 439), - Trans(5, 24, 3, 439), - Trans(5, 25, 3, 439), - Trans(5, 26, 3, 439), - Trans(5, 27, 3, 439), - Trans(5, 39, 3, 439), - Trans(5, 40, 3, 439), - Trans(5, 42, 3, 439), - Trans(5, 54, 3, 439), - Trans(5, 58, 3, 439), - Trans(5, 71, 3, 439), - Trans(5, 77, 3, 439), - Trans(5, 84, 3, 439), - Trans(5, 87, 3, 439), - Trans(5, 89, 3, 439), - Trans(5, 106, 3, 439), - Trans(5, 114, 3, 439), - Trans(5, 115, 3, 439), - Trans(6, 5, 3, 439), - Trans(6, 40, 3, 439), - Trans(7, 5, 3, 439), - Trans(7, 16, 3, 439), - Trans(7, 17, 3, 439), - Trans(7, 18, 3, 439), - Trans(7, 19, 3, 439), - Trans(7, 20, 3, 439), - Trans(7, 21, 3, 439), - Trans(7, 22, 3, 439), - Trans(7, 23, 3, 439), - Trans(7, 24, 3, 439), - Trans(7, 25, 3, 439), - Trans(7, 26, 3, 439), - Trans(7, 30, 3, 439), - Trans(7, 32, 3, 439), - Trans(7, 35, 3, 439), - Trans(7, 41, 3, 439), - Trans(7, 42, 3, 439), - Trans(7, 44, 3, 439), - Trans(7, 48, 3, 439), - Trans(7, 52, 3, 439), - Trans(7, 94, 3, 439), - Trans(8, 5, 3, 439), - Trans(8, 16, 3, 439), - Trans(8, 17, 3, 439), - Trans(8, 18, 3, 439), - Trans(8, 19, 3, 439), - Trans(8, 20, 3, 439), - Trans(8, 21, 3, 439), - Trans(8, 22, 3, 439), - Trans(8, 23, 3, 439), - Trans(8, 24, 3, 439), - Trans(8, 25, 3, 439), - Trans(8, 26, 3, 439), - Trans(8, 29, 3, 439), - Trans(8, 30, 3, 439), - Trans(8, 32, 3, 439), - Trans(8, 35, 3, 439), - Trans(8, 41, 3, 439), - Trans(8, 42, 3, 439), - Trans(8, 44, 3, 439), - Trans(8, 48, 3, 439), - Trans(8, 52, 3, 439), - Trans(8, 94, 3, 439), - Trans(9, 6, 3, 439), - Trans(9, 7, 3, 439), - Trans(9, 8, 3, 439), - Trans(9, 9, 3, 439), - Trans(9, 10, 3, 439), - Trans(9, 11, 3, 439), - Trans(9, 18, 3, 439), - Trans(9, 24, 3, 439), - Trans(9, 25, 3, 439), - Trans(9, 26, 3, 439), - Trans(9, 27, 3, 439), - Trans(9, 39, 3, 439), - Trans(9, 40, 3, 439), - Trans(9, 42, 3, 439), - Trans(9, 44, 23, 440), - Trans(9, 54, 3, 439), - Trans(9, 71, 3, 439), - Trans(9, 77, 3, 439), - Trans(9, 84, 3, 439), - Trans(9, 87, 3, 439), - Trans(9, 89, 3, 439), - Trans(9, 106, 3, 439), - Trans(9, 114, 3, 439), - Trans(9, 115, 3, 439), - 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, 31, 13, -1), - Trans(10, 32, 14, -1), - Trans(10, 33, 12, -1), - Trans(10, 34, 12, -1), - Trans(10, 40, 15, -1), - Trans(10, 43, 16, -1), - Trans(10, 44, 17, -1), - Trans(10, 45, 18, -1), - Trans(10, 46, 19, -1), - Trans(10, 47, 20, -1), - Trans(10, 48, 12, -1), - Trans(10, 52, 21, -1), - Trans(10, 94, 12, -1), - Trans(10, 103, 22, -1), + Trans(10, 96, 12, -1), + Trans(10, 105, 22, -1), Trans(11, 12, 23, 440), Trans(11, 14, 23, 440), Trans(11, 16, 23, 440), @@ -3594,8 +1571,8 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(11, 47, 23, 440), Trans(11, 48, 23, 440), Trans(11, 52, 23, 440), - Trans(11, 94, 23, 440), - Trans(11, 103, 23, 440), + Trans(11, 96, 23, 440), + Trans(11, 105, 23, 440), Trans(12, 5, 23, 440), Trans(12, 6, 23, 440), Trans(12, 7, 23, 440), @@ -3612,14 +1589,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(12, 40, 23, 440), Trans(12, 42, 23, 440), Trans(12, 54, 23, 440), - Trans(12, 71, 23, 440), - Trans(12, 77, 23, 440), - Trans(12, 84, 23, 440), - Trans(12, 87, 23, 440), - Trans(12, 89, 23, 440), - Trans(12, 106, 23, 440), - Trans(12, 114, 23, 440), - Trans(12, 115, 23, 440), + Trans(12, 72, 23, 440), + Trans(12, 78, 23, 440), + Trans(12, 85, 23, 440), + Trans(12, 88, 23, 440), + Trans(12, 90, 23, 440), + Trans(12, 108, 23, 440), + Trans(12, 116, 23, 440), + Trans(12, 117, 23, 440), Trans(13, 5, 23, 440), Trans(13, 6, 23, 440), Trans(13, 7, 23, 440), @@ -3636,19 +1613,19 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(13, 40, 23, 440), Trans(13, 42, 23, 440), Trans(13, 54, 23, 440), - Trans(13, 66, 23, 440), - Trans(13, 70, 23, 440), + Trans(13, 67, 23, 440), Trans(13, 71, 23, 440), - Trans(13, 77, 23, 440), - Trans(13, 81, 23, 440), - Trans(13, 84, 23, 440), - Trans(13, 87, 23, 440), - Trans(13, 89, 23, 440), - Trans(13, 100, 23, 440), - Trans(13, 101, 23, 440), - Trans(13, 106, 23, 440), - Trans(13, 114, 23, 440), - Trans(13, 115, 23, 440), + Trans(13, 72, 23, 440), + Trans(13, 78, 23, 440), + Trans(13, 82, 23, 440), + Trans(13, 85, 23, 440), + Trans(13, 88, 23, 440), + Trans(13, 90, 23, 440), + Trans(13, 102, 23, 440), + Trans(13, 103, 23, 440), + Trans(13, 108, 23, 440), + Trans(13, 116, 23, 440), + Trans(13, 117, 23, 440), Trans(14, 5, 23, 440), Trans(14, 6, 23, 440), Trans(14, 7, 23, 440), @@ -3668,17 +1645,17 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(14, 44, 23, 440), Trans(14, 46, 23, 440), Trans(14, 54, 23, 440), - Trans(14, 58, 23, 440), - Trans(14, 71, 23, 440), - Trans(14, 77, 23, 440), - Trans(14, 82, 23, 440), - Trans(14, 84, 23, 440), - Trans(14, 87, 23, 440), - Trans(14, 89, 23, 440), - Trans(14, 91, 23, 440), - Trans(14, 106, 23, 440), - Trans(14, 114, 23, 440), - Trans(14, 115, 23, 440), + Trans(14, 59, 23, 440), + Trans(14, 72, 23, 440), + Trans(14, 78, 23, 440), + Trans(14, 83, 23, 440), + Trans(14, 85, 23, 440), + Trans(14, 88, 23, 440), + Trans(14, 90, 23, 440), + Trans(14, 92, 23, 440), + Trans(14, 108, 23, 440), + Trans(14, 116, 23, 440), + Trans(14, 117, 23, 440), Trans(15, 5, 23, 440), Trans(15, 6, 23, 440), Trans(15, 7, 23, 440), @@ -3701,33 +1678,33 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(15, 50, 23, 440), Trans(15, 51, 23, 440), Trans(15, 54, 23, 440), - Trans(15, 58, 23, 440), - Trans(15, 61, 23, 440), - Trans(15, 65, 23, 440), + Trans(15, 59, 23, 440), + Trans(15, 62, 23, 440), Trans(15, 66, 23, 440), Trans(15, 67, 23, 440), - Trans(15, 70, 23, 440), + Trans(15, 68, 23, 440), Trans(15, 71, 23, 440), Trans(15, 72, 23, 440), - Trans(15, 74, 23, 440), - Trans(15, 77, 23, 440), + Trans(15, 73, 23, 440), + Trans(15, 75, 23, 440), Trans(15, 78, 23, 440), - Trans(15, 81, 23, 440), + Trans(15, 79, 23, 440), Trans(15, 82, 23, 440), - Trans(15, 84, 23, 440), + Trans(15, 83, 23, 440), Trans(15, 85, 23, 440), - Trans(15, 87, 23, 440), - Trans(15, 89, 23, 440), - Trans(15, 100, 23, 440), - Trans(15, 101, 23, 440), - Trans(15, 105, 23, 440), - Trans(15, 106, 23, 440), + Trans(15, 86, 23, 440), + Trans(15, 88, 23, 440), + Trans(15, 90, 23, 440), + Trans(15, 102, 23, 440), + Trans(15, 103, 23, 440), + Trans(15, 107, 23, 440), Trans(15, 108, 23, 440), - Trans(15, 111, 23, 440), - Trans(15, 112, 23, 440), + Trans(15, 110, 23, 440), Trans(15, 113, 23, 440), Trans(15, 114, 23, 440), Trans(15, 115, 23, 440), + Trans(15, 116, 23, 440), + Trans(15, 117, 23, 440), Trans(16, 5, 23, 440), Trans(16, 32, 23, 440), Trans(16, 36, 23, 440), @@ -3736,7 +1713,7 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(16, 44, 23, 440), Trans(16, 46, 23, 440), Trans(16, 47, 23, 440), - Trans(16, 80, 23, 440), + Trans(16, 81, 23, 440), Trans(17, 5, 23, 440), Trans(17, 12, 23, 440), Trans(17, 14, 23, 440), @@ -3767,26 +1744,26 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(17, 50, 23, 440), Trans(17, 51, 23, 440), Trans(17, 52, 23, 440), - Trans(17, 59, 23, 440), - Trans(17, 61, 23, 440), + Trans(17, 60, 23, 440), Trans(17, 62, 23, 440), - Trans(17, 65, 23, 440), + Trans(17, 63, 23, 440), Trans(17, 66, 23, 440), Trans(17, 67, 23, 440), - Trans(17, 71, 23, 440), + Trans(17, 68, 23, 440), Trans(17, 72, 23, 440), - Trans(17, 74, 23, 440), - Trans(17, 78, 23, 440), - Trans(17, 81, 23, 440), + Trans(17, 73, 23, 440), + Trans(17, 75, 23, 440), + Trans(17, 79, 23, 440), Trans(17, 82, 23, 440), - Trans(17, 85, 23, 440), - Trans(17, 94, 23, 440), - Trans(17, 103, 23, 440), + Trans(17, 83, 23, 440), + Trans(17, 86, 23, 440), + Trans(17, 96, 23, 440), Trans(17, 105, 23, 440), - Trans(17, 108, 23, 440), - Trans(17, 111, 23, 440), - Trans(17, 112, 23, 440), + Trans(17, 107, 23, 440), + Trans(17, 110, 23, 440), Trans(17, 113, 23, 440), + Trans(17, 114, 23, 440), + Trans(17, 115, 23, 440), Trans(18, 5, 23, 440), Trans(18, 12, 23, 440), Trans(18, 14, 23, 440), @@ -3819,8 +1796,8 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(18, 47, 23, 440), Trans(18, 48, 23, 440), Trans(18, 52, 23, 440), - Trans(18, 94, 23, 440), - Trans(18, 103, 23, 440), + Trans(18, 96, 23, 440), + Trans(18, 105, 23, 440), Trans(19, 5, 23, 440), Trans(19, 12, 23, 440), Trans(19, 14, 23, 440), @@ -3848,8 +1825,8 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(19, 47, 23, 440), Trans(19, 48, 23, 440), Trans(19, 52, 23, 440), - Trans(19, 94, 23, 440), - Trans(19, 103, 23, 440), + Trans(19, 96, 23, 440), + Trans(19, 105, 23, 440), Trans(20, 5, 23, 440), Trans(20, 6, 23, 440), Trans(20, 7, 23, 440), @@ -3872,51 +1849,51 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(20, 50, 23, 440), Trans(20, 51, 23, 440), Trans(20, 54, 23, 440), - Trans(20, 58, 23, 440), - Trans(20, 61, 23, 440), + Trans(20, 59, 23, 440), Trans(20, 62, 23, 440), - Trans(20, 65, 23, 440), + Trans(20, 63, 23, 440), Trans(20, 66, 23, 440), Trans(20, 67, 23, 440), - Trans(20, 70, 23, 440), + Trans(20, 68, 23, 440), Trans(20, 71, 23, 440), Trans(20, 72, 23, 440), - Trans(20, 74, 23, 440), - Trans(20, 77, 23, 440), + Trans(20, 73, 23, 440), + Trans(20, 75, 23, 440), Trans(20, 78, 23, 440), - Trans(20, 81, 23, 440), + Trans(20, 79, 23, 440), Trans(20, 82, 23, 440), - Trans(20, 84, 23, 440), + Trans(20, 83, 23, 440), Trans(20, 85, 23, 440), - Trans(20, 87, 23, 440), - Trans(20, 89, 23, 440), - Trans(20, 100, 23, 440), - Trans(20, 101, 23, 440), - Trans(20, 105, 23, 440), - Trans(20, 106, 23, 440), + Trans(20, 86, 23, 440), + Trans(20, 88, 23, 440), + Trans(20, 90, 23, 440), + Trans(20, 102, 23, 440), + Trans(20, 103, 23, 440), + Trans(20, 107, 23, 440), Trans(20, 108, 23, 440), - Trans(20, 111, 23, 440), - Trans(20, 112, 23, 440), + Trans(20, 110, 23, 440), Trans(20, 113, 23, 440), Trans(20, 114, 23, 440), Trans(20, 115, 23, 440), + Trans(20, 116, 23, 440), + Trans(20, 117, 23, 440), Trans(21, 5, 23, 440), Trans(21, 55, 23, 440), Trans(21, 56, 23, 440), Trans(21, 57, 23, 440), - Trans(21, 63, 23, 440), Trans(21, 64, 23, 440), - Trans(21, 68, 23, 440), + Trans(21, 65, 23, 440), Trans(21, 69, 23, 440), - Trans(21, 95, 23, 440), - Trans(21, 96, 23, 440), + Trans(21, 70, 23, 440), Trans(21, 97, 23, 440), Trans(21, 98, 23, 440), Trans(21, 99, 23, 440), - Trans(21, 109, 23, 440), - Trans(21, 110, 23, 440), - Trans(21, 114, 23, 440), - Trans(21, 115, 23, 440), + Trans(21, 100, 23, 440), + Trans(21, 101, 23, 440), + Trans(21, 111, 23, 440), + Trans(21, 112, 23, 440), + Trans(21, 116, 23, 440), + Trans(21, 117, 23, 440), Trans(22, 5, 23, 440), Trans(22, 6, 23, 440), Trans(22, 7, 23, 440), @@ -3934,14 +1911,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(22, 40, 23, 440), Trans(22, 42, 23, 440), Trans(22, 54, 23, 440), - Trans(22, 71, 23, 440), - Trans(22, 77, 23, 440), - Trans(22, 84, 23, 440), - Trans(22, 87, 23, 440), - Trans(22, 89, 23, 440), - Trans(22, 106, 23, 440), - Trans(22, 114, 23, 440), - Trans(22, 115, 23, 440), + Trans(22, 72, 23, 440), + Trans(22, 78, 23, 440), + Trans(22, 85, 23, 440), + Trans(22, 88, 23, 440), + Trans(22, 90, 23, 440), + Trans(22, 108, 23, 440), + Trans(22, 116, 23, 440), + Trans(22, 117, 23, 440), Trans(24, 5, 23, 440), Trans(24, 12, 23, 440), Trans(24, 14, 23, 440), @@ -3968,387 +1945,2464 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(24, 47, 23, 440), Trans(24, 48, 23, 440), Trans(24, 52, 23, 440), - Trans(24, 94, 23, 440), - Trans(24, 103, 23, 440), + Trans(24, 96, 23, 440), + Trans(24, 105, 23, 440), + ], + k: 3, + }, + /* 22 - "ArgumentListOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 32, 1, 441), Trans(0, 46, 2, 442)], + k: 1, + }, + /* 23 - "Array" */ + LookaheadDFA { + prod0: 495, + transitions: &[], + k: 0, + }, + /* 24 - "ArrayList" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 32, 1, 496), Trans(0, 45, 2, 497)], + k: 1, + }, + /* 25 - "ArrayLiteralItem" */ + LookaheadDFA { + prod0: 457, + transitions: &[], + k: 0, + }, + /* 26 - "ArrayLiteralItemGroup" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 6, 1, 458), + Trans(0, 7, 1, 458), + Trans(0, 8, 1, 458), + Trans(0, 9, 1, 458), + Trans(0, 10, 1, 458), + Trans(0, 11, 1, 458), + Trans(0, 18, 1, 458), + Trans(0, 24, 1, 458), + Trans(0, 25, 1, 458), + Trans(0, 26, 1, 458), + Trans(0, 27, 1, 458), + Trans(0, 39, 1, 458), + Trans(0, 40, 1, 458), + Trans(0, 42, 1, 458), + Trans(0, 54, 1, 458), + Trans(0, 59, 2, 459), + Trans(0, 72, 1, 458), + Trans(0, 78, 1, 458), + Trans(0, 85, 1, 458), + Trans(0, 88, 1, 458), + Trans(0, 90, 1, 458), + Trans(0, 108, 1, 458), + Trans(0, 116, 1, 458), + Trans(0, 117, 1, 458), + ], + k: 1, + }, + /* 27 - "ArrayLiteralItemOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 32, 2, 461), + Trans(0, 44, 2, 461), + Trans(0, 96, 1, 460), + ], + k: 1, + }, + /* 28 - "ArrayLiteralList" */ + LookaheadDFA { + prod0: 452, + transitions: &[], + k: 0, + }, + /* 29 - "ArrayLiteralListList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 32, 1, -1), + Trans(0, 44, 11, -1), + Trans(1, 5, 10, -1), + Trans(1, 6, 2, -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, 18, 4, -1), + Trans(1, 24, 4, -1), + Trans(1, 25, 4, -1), + Trans(1, 26, 4, -1), + Trans(1, 27, 4, -1), + Trans(1, 39, 5, -1), + Trans(1, 40, 4, -1), + Trans(1, 42, 4, -1), + Trans(1, 44, 25, -1), + Trans(1, 54, 4, -1), + Trans(1, 59, 6, -1), + Trans(1, 72, 4, -1), + Trans(1, 78, 4, -1), + Trans(1, 85, 2, -1), + Trans(1, 88, 2, -1), + Trans(1, 90, 4, -1), + Trans(1, 108, 7, -1), + Trans(1, 116, 8, -1), + Trans(1, 117, 9, -1), + Trans(2, 5, 3, 453), + Trans(2, 16, 3, 453), + Trans(2, 17, 3, 453), + Trans(2, 18, 3, 453), + Trans(2, 19, 3, 453), + Trans(2, 20, 3, 453), + Trans(2, 21, 3, 453), + Trans(2, 22, 3, 453), + Trans(2, 23, 3, 453), + Trans(2, 24, 3, 453), + Trans(2, 25, 3, 453), + Trans(2, 26, 3, 453), + Trans(2, 32, 3, 453), + Trans(2, 44, 3, 453), + Trans(2, 48, 3, 453), + Trans(2, 52, 3, 453), + Trans(2, 96, 3, 453), + Trans(4, 5, 3, 453), + Trans(4, 6, 3, 453), + Trans(4, 7, 3, 453), + Trans(4, 8, 3, 453), + Trans(4, 9, 3, 453), + Trans(4, 10, 3, 453), + Trans(4, 11, 3, 453), + Trans(4, 18, 3, 453), + Trans(4, 24, 3, 453), + Trans(4, 25, 3, 453), + Trans(4, 26, 3, 453), + Trans(4, 27, 3, 453), + Trans(4, 39, 3, 453), + Trans(4, 40, 3, 453), + Trans(4, 42, 3, 453), + Trans(4, 54, 3, 453), + Trans(4, 72, 3, 453), + Trans(4, 78, 3, 453), + Trans(4, 85, 3, 453), + Trans(4, 88, 3, 453), + Trans(4, 90, 3, 453), + Trans(4, 108, 3, 453), + Trans(4, 116, 3, 453), + Trans(4, 117, 3, 453), + Trans(5, 5, 3, 453), + Trans(5, 6, 3, 453), + Trans(5, 7, 3, 453), + Trans(5, 8, 3, 453), + Trans(5, 9, 3, 453), + Trans(5, 10, 3, 453), + Trans(5, 11, 3, 453), + Trans(5, 18, 3, 453), + Trans(5, 24, 3, 453), + Trans(5, 25, 3, 453), + Trans(5, 26, 3, 453), + Trans(5, 27, 3, 453), + Trans(5, 39, 3, 453), + Trans(5, 40, 3, 453), + Trans(5, 42, 3, 453), + Trans(5, 54, 3, 453), + Trans(5, 59, 3, 453), + Trans(5, 72, 3, 453), + Trans(5, 78, 3, 453), + Trans(5, 85, 3, 453), + Trans(5, 88, 3, 453), + Trans(5, 90, 3, 453), + Trans(5, 108, 3, 453), + Trans(5, 116, 3, 453), + Trans(5, 117, 3, 453), + Trans(6, 5, 3, 453), + Trans(6, 31, 3, 453), + Trans(7, 5, 3, 453), + Trans(7, 40, 3, 453), + Trans(8, 5, 3, 453), + Trans(8, 16, 3, 453), + Trans(8, 17, 3, 453), + Trans(8, 18, 3, 453), + Trans(8, 19, 3, 453), + Trans(8, 20, 3, 453), + Trans(8, 21, 3, 453), + Trans(8, 22, 3, 453), + Trans(8, 23, 3, 453), + Trans(8, 24, 3, 453), + Trans(8, 25, 3, 453), + Trans(8, 26, 3, 453), + Trans(8, 30, 3, 453), + Trans(8, 32, 3, 453), + Trans(8, 35, 3, 453), + Trans(8, 41, 3, 453), + Trans(8, 42, 3, 453), + Trans(8, 44, 3, 453), + Trans(8, 48, 3, 453), + Trans(8, 52, 3, 453), + Trans(8, 96, 3, 453), + Trans(9, 5, 3, 453), + Trans(9, 16, 3, 453), + Trans(9, 17, 3, 453), + Trans(9, 18, 3, 453), + Trans(9, 19, 3, 453), + Trans(9, 20, 3, 453), + Trans(9, 21, 3, 453), + Trans(9, 22, 3, 453), + Trans(9, 23, 3, 453), + Trans(9, 24, 3, 453), + Trans(9, 25, 3, 453), + Trans(9, 26, 3, 453), + Trans(9, 29, 3, 453), + Trans(9, 30, 3, 453), + Trans(9, 32, 3, 453), + Trans(9, 35, 3, 453), + Trans(9, 41, 3, 453), + Trans(9, 42, 3, 453), + Trans(9, 44, 3, 453), + Trans(9, 48, 3, 453), + Trans(9, 52, 3, 453), + Trans(9, 96, 3, 453), + Trans(10, 6, 3, 453), + Trans(10, 7, 3, 453), + Trans(10, 8, 3, 453), + Trans(10, 9, 3, 453), + Trans(10, 10, 3, 453), + Trans(10, 11, 3, 453), + Trans(10, 18, 3, 453), + Trans(10, 24, 3, 453), + Trans(10, 25, 3, 453), + Trans(10, 26, 3, 453), + Trans(10, 27, 3, 453), + Trans(10, 39, 3, 453), + Trans(10, 40, 3, 453), + Trans(10, 42, 3, 453), + Trans(10, 44, 24, 454), + Trans(10, 54, 3, 453), + Trans(10, 59, 3, 453), + Trans(10, 72, 3, 453), + Trans(10, 78, 3, 453), + Trans(10, 85, 3, 453), + Trans(10, 88, 3, 453), + Trans(10, 90, 3, 453), + Trans(10, 108, 3, 453), + Trans(10, 116, 3, 453), + Trans(10, 117, 3, 453), + Trans(11, 5, 12, -1), + Trans(11, 12, 13, -1), + Trans(11, 14, 13, -1), + Trans(11, 16, 13, -1), + Trans(11, 17, 13, -1), + Trans(11, 18, 13, -1), + Trans(11, 19, 13, -1), + Trans(11, 20, 13, -1), + Trans(11, 21, 13, -1), + Trans(11, 22, 13, -1), + Trans(11, 23, 13, -1), + Trans(11, 24, 13, -1), + Trans(11, 25, 13, -1), + Trans(11, 26, 13, -1), + Trans(11, 31, 14, -1), + Trans(11, 32, 15, -1), + Trans(11, 33, 13, -1), + Trans(11, 34, 13, -1), + Trans(11, 40, 16, -1), + Trans(11, 43, 17, -1), + Trans(11, 44, 18, -1), + Trans(11, 45, 19, -1), + Trans(11, 46, 20, -1), + Trans(11, 47, 21, -1), + Trans(11, 48, 13, -1), + Trans(11, 52, 22, -1), + Trans(11, 96, 13, -1), + Trans(11, 105, 23, -1), + Trans(12, 12, 24, 454), + Trans(12, 14, 24, 454), + Trans(12, 16, 24, 454), + Trans(12, 17, 24, 454), + Trans(12, 18, 24, 454), + Trans(12, 19, 24, 454), + Trans(12, 20, 24, 454), + Trans(12, 21, 24, 454), + Trans(12, 22, 24, 454), + Trans(12, 23, 24, 454), + Trans(12, 24, 24, 454), + Trans(12, 25, 24, 454), + Trans(12, 26, 24, 454), + Trans(12, 31, 24, 454), + Trans(12, 32, 24, 454), + Trans(12, 33, 24, 454), + Trans(12, 34, 24, 454), + Trans(12, 40, 24, 454), + Trans(12, 43, 24, 454), + Trans(12, 44, 24, 454), + Trans(12, 45, 24, 454), + Trans(12, 46, 24, 454), + Trans(12, 47, 24, 454), + Trans(12, 48, 24, 454), + Trans(12, 52, 24, 454), + Trans(12, 96, 24, 454), + Trans(12, 105, 24, 454), + Trans(13, 5, 24, 454), + Trans(13, 6, 24, 454), + Trans(13, 7, 24, 454), + Trans(13, 8, 24, 454), + Trans(13, 9, 24, 454), + Trans(13, 10, 24, 454), + Trans(13, 11, 24, 454), + Trans(13, 18, 24, 454), + Trans(13, 24, 24, 454), + Trans(13, 25, 24, 454), + Trans(13, 26, 24, 454), + Trans(13, 27, 24, 454), + Trans(13, 39, 24, 454), + Trans(13, 40, 24, 454), + Trans(13, 42, 24, 454), + Trans(13, 54, 24, 454), + Trans(13, 72, 24, 454), + Trans(13, 78, 24, 454), + Trans(13, 85, 24, 454), + Trans(13, 88, 24, 454), + Trans(13, 90, 24, 454), + Trans(13, 108, 24, 454), + Trans(13, 116, 24, 454), + Trans(13, 117, 24, 454), + Trans(14, 5, 24, 454), + Trans(14, 6, 24, 454), + Trans(14, 7, 24, 454), + Trans(14, 8, 24, 454), + Trans(14, 9, 24, 454), + Trans(14, 10, 24, 454), + Trans(14, 11, 24, 454), + Trans(14, 18, 24, 454), + Trans(14, 24, 24, 454), + Trans(14, 25, 24, 454), + Trans(14, 26, 24, 454), + Trans(14, 27, 24, 454), + Trans(14, 39, 24, 454), + Trans(14, 40, 24, 454), + Trans(14, 42, 24, 454), + Trans(14, 54, 24, 454), + Trans(14, 67, 24, 454), + Trans(14, 71, 24, 454), + Trans(14, 72, 24, 454), + Trans(14, 78, 24, 454), + Trans(14, 82, 24, 454), + Trans(14, 85, 24, 454), + Trans(14, 88, 24, 454), + Trans(14, 90, 24, 454), + Trans(14, 102, 24, 454), + Trans(14, 103, 24, 454), + Trans(14, 108, 24, 454), + Trans(14, 116, 24, 454), + Trans(14, 117, 24, 454), + Trans(15, 5, 24, 454), + Trans(15, 6, 24, 454), + Trans(15, 7, 24, 454), + Trans(15, 8, 24, 454), + Trans(15, 9, 24, 454), + Trans(15, 10, 24, 454), + Trans(15, 11, 24, 454), + Trans(15, 18, 24, 454), + Trans(15, 24, 24, 454), + Trans(15, 25, 24, 454), + Trans(15, 26, 24, 454), + Trans(15, 27, 24, 454), + Trans(15, 37, 24, 454), + Trans(15, 39, 24, 454), + Trans(15, 40, 24, 454), + Trans(15, 42, 24, 454), + Trans(15, 44, 24, 454), + Trans(15, 46, 24, 454), + Trans(15, 54, 24, 454), + Trans(15, 59, 24, 454), + Trans(15, 72, 24, 454), + Trans(15, 78, 24, 454), + Trans(15, 83, 24, 454), + Trans(15, 85, 24, 454), + Trans(15, 88, 24, 454), + Trans(15, 90, 24, 454), + Trans(15, 92, 24, 454), + Trans(15, 108, 24, 454), + Trans(15, 116, 24, 454), + Trans(15, 117, 24, 454), + Trans(16, 5, 24, 454), + Trans(16, 6, 24, 454), + Trans(16, 7, 24, 454), + Trans(16, 8, 24, 454), + Trans(16, 9, 24, 454), + Trans(16, 10, 24, 454), + Trans(16, 11, 24, 454), + Trans(16, 18, 24, 454), + Trans(16, 24, 24, 454), + Trans(16, 25, 24, 454), + Trans(16, 26, 24, 454), + Trans(16, 27, 24, 454), + Trans(16, 31, 24, 454), + Trans(16, 37, 24, 454), + Trans(16, 39, 24, 454), + Trans(16, 40, 24, 454), + Trans(16, 42, 24, 454), + Trans(16, 44, 24, 454), + Trans(16, 49, 24, 454), + Trans(16, 50, 24, 454), + Trans(16, 51, 24, 454), + Trans(16, 54, 24, 454), + Trans(16, 59, 24, 454), + Trans(16, 62, 24, 454), + Trans(16, 66, 24, 454), + Trans(16, 67, 24, 454), + Trans(16, 68, 24, 454), + Trans(16, 71, 24, 454), + Trans(16, 72, 24, 454), + Trans(16, 73, 24, 454), + Trans(16, 75, 24, 454), + Trans(16, 78, 24, 454), + Trans(16, 79, 24, 454), + Trans(16, 82, 24, 454), + Trans(16, 83, 24, 454), + Trans(16, 85, 24, 454), + Trans(16, 86, 24, 454), + Trans(16, 88, 24, 454), + Trans(16, 90, 24, 454), + Trans(16, 102, 24, 454), + Trans(16, 103, 24, 454), + Trans(16, 107, 24, 454), + Trans(16, 108, 24, 454), + Trans(16, 110, 24, 454), + Trans(16, 113, 24, 454), + Trans(16, 114, 24, 454), + Trans(16, 115, 24, 454), + Trans(16, 116, 24, 454), + Trans(16, 117, 24, 454), + Trans(17, 5, 24, 454), + Trans(17, 32, 24, 454), + Trans(17, 36, 24, 454), + Trans(17, 40, 24, 454), + Trans(17, 41, 24, 454), + Trans(17, 44, 24, 454), + Trans(17, 46, 24, 454), + Trans(17, 47, 24, 454), + Trans(17, 81, 24, 454), + Trans(18, 5, 24, 454), + Trans(18, 12, 24, 454), + Trans(18, 14, 24, 454), + Trans(18, 16, 24, 454), + Trans(18, 17, 24, 454), + Trans(18, 18, 24, 454), + Trans(18, 19, 24, 454), + Trans(18, 20, 24, 454), + Trans(18, 21, 24, 454), + Trans(18, 22, 24, 454), + Trans(18, 23, 24, 454), + Trans(18, 24, 24, 454), + Trans(18, 25, 24, 454), + Trans(18, 26, 24, 454), + Trans(18, 31, 24, 454), + Trans(18, 32, 24, 454), + Trans(18, 33, 24, 454), + Trans(18, 34, 24, 454), + Trans(18, 37, 24, 454), + Trans(18, 40, 24, 454), + Trans(18, 43, 24, 454), + Trans(18, 44, 24, 454), + Trans(18, 45, 24, 454), + Trans(18, 46, 24, 454), + Trans(18, 47, 24, 454), + Trans(18, 48, 24, 454), + Trans(18, 49, 24, 454), + Trans(18, 50, 24, 454), + Trans(18, 51, 24, 454), + Trans(18, 52, 24, 454), + Trans(18, 60, 24, 454), + Trans(18, 62, 24, 454), + Trans(18, 63, 24, 454), + Trans(18, 66, 24, 454), + Trans(18, 67, 24, 454), + Trans(18, 68, 24, 454), + Trans(18, 72, 24, 454), + Trans(18, 73, 24, 454), + Trans(18, 75, 24, 454), + Trans(18, 79, 24, 454), + Trans(18, 82, 24, 454), + Trans(18, 83, 24, 454), + Trans(18, 86, 24, 454), + Trans(18, 96, 24, 454), + Trans(18, 105, 24, 454), + Trans(18, 107, 24, 454), + Trans(18, 110, 24, 454), + Trans(18, 113, 24, 454), + Trans(18, 114, 24, 454), + Trans(18, 115, 24, 454), + Trans(19, 5, 24, 454), + Trans(19, 12, 24, 454), + Trans(19, 14, 24, 454), + Trans(19, 15, 24, 454), + Trans(19, 16, 24, 454), + Trans(19, 17, 24, 454), + Trans(19, 18, 24, 454), + Trans(19, 19, 24, 454), + Trans(19, 20, 24, 454), + Trans(19, 21, 24, 454), + Trans(19, 22, 24, 454), + Trans(19, 23, 24, 454), + Trans(19, 24, 24, 454), + Trans(19, 25, 24, 454), + Trans(19, 26, 24, 454), + Trans(19, 31, 24, 454), + Trans(19, 32, 24, 454), + Trans(19, 33, 24, 454), + Trans(19, 34, 24, 454), + Trans(19, 35, 24, 454), + Trans(19, 36, 24, 454), + Trans(19, 37, 24, 454), + Trans(19, 40, 24, 454), + Trans(19, 41, 24, 454), + Trans(19, 42, 24, 454), + Trans(19, 43, 24, 454), + Trans(19, 44, 24, 454), + Trans(19, 45, 24, 454), + Trans(19, 46, 24, 454), + Trans(19, 47, 24, 454), + Trans(19, 48, 24, 454), + Trans(19, 52, 24, 454), + Trans(19, 96, 24, 454), + Trans(19, 105, 24, 454), + Trans(20, 5, 24, 454), + Trans(20, 12, 24, 454), + Trans(20, 14, 24, 454), + Trans(20, 16, 24, 454), + Trans(20, 17, 24, 454), + Trans(20, 18, 24, 454), + Trans(20, 19, 24, 454), + Trans(20, 20, 24, 454), + Trans(20, 21, 24, 454), + Trans(20, 22, 24, 454), + Trans(20, 23, 24, 454), + Trans(20, 24, 24, 454), + Trans(20, 25, 24, 454), + Trans(20, 26, 24, 454), + Trans(20, 31, 24, 454), + Trans(20, 32, 24, 454), + Trans(20, 33, 24, 454), + Trans(20, 34, 24, 454), + Trans(20, 40, 24, 454), + Trans(20, 42, 24, 454), + Trans(20, 43, 24, 454), + Trans(20, 44, 24, 454), + Trans(20, 45, 24, 454), + Trans(20, 46, 24, 454), + Trans(20, 47, 24, 454), + Trans(20, 48, 24, 454), + Trans(20, 52, 24, 454), + Trans(20, 96, 24, 454), + Trans(20, 105, 24, 454), + Trans(21, 5, 24, 454), + Trans(21, 6, 24, 454), + Trans(21, 7, 24, 454), + Trans(21, 8, 24, 454), + Trans(21, 9, 24, 454), + Trans(21, 10, 24, 454), + Trans(21, 11, 24, 454), + Trans(21, 18, 24, 454), + Trans(21, 24, 24, 454), + Trans(21, 25, 24, 454), + Trans(21, 26, 24, 454), + Trans(21, 27, 24, 454), + Trans(21, 31, 24, 454), + Trans(21, 37, 24, 454), + Trans(21, 39, 24, 454), + Trans(21, 40, 24, 454), + Trans(21, 42, 24, 454), + Trans(21, 44, 24, 454), + Trans(21, 49, 24, 454), + Trans(21, 50, 24, 454), + Trans(21, 51, 24, 454), + Trans(21, 54, 24, 454), + Trans(21, 59, 24, 454), + Trans(21, 62, 24, 454), + Trans(21, 63, 24, 454), + Trans(21, 66, 24, 454), + Trans(21, 67, 24, 454), + Trans(21, 68, 24, 454), + Trans(21, 71, 24, 454), + Trans(21, 72, 24, 454), + Trans(21, 73, 24, 454), + Trans(21, 75, 24, 454), + Trans(21, 78, 24, 454), + Trans(21, 79, 24, 454), + Trans(21, 82, 24, 454), + Trans(21, 83, 24, 454), + Trans(21, 85, 24, 454), + Trans(21, 86, 24, 454), + Trans(21, 88, 24, 454), + Trans(21, 90, 24, 454), + Trans(21, 102, 24, 454), + Trans(21, 103, 24, 454), + Trans(21, 107, 24, 454), + Trans(21, 108, 24, 454), + Trans(21, 110, 24, 454), + Trans(21, 113, 24, 454), + Trans(21, 114, 24, 454), + Trans(21, 115, 24, 454), + Trans(21, 116, 24, 454), + Trans(21, 117, 24, 454), + Trans(22, 5, 24, 454), + Trans(22, 55, 24, 454), + Trans(22, 56, 24, 454), + Trans(22, 57, 24, 454), + Trans(22, 64, 24, 454), + Trans(22, 65, 24, 454), + Trans(22, 69, 24, 454), + Trans(22, 70, 24, 454), + Trans(22, 97, 24, 454), + Trans(22, 98, 24, 454), + Trans(22, 99, 24, 454), + Trans(22, 100, 24, 454), + Trans(22, 101, 24, 454), + Trans(22, 111, 24, 454), + Trans(22, 112, 24, 454), + Trans(22, 116, 24, 454), + Trans(22, 117, 24, 454), + Trans(23, 5, 24, 454), + Trans(23, 6, 24, 454), + Trans(23, 7, 24, 454), + Trans(23, 8, 24, 454), + Trans(23, 9, 24, 454), + Trans(23, 10, 24, 454), + Trans(23, 11, 24, 454), + Trans(23, 15, 24, 454), + Trans(23, 18, 24, 454), + Trans(23, 24, 24, 454), + Trans(23, 25, 24, 454), + Trans(23, 26, 24, 454), + Trans(23, 27, 24, 454), + Trans(23, 39, 24, 454), + Trans(23, 40, 24, 454), + Trans(23, 42, 24, 454), + Trans(23, 54, 24, 454), + Trans(23, 72, 24, 454), + Trans(23, 78, 24, 454), + Trans(23, 85, 24, 454), + Trans(23, 88, 24, 454), + Trans(23, 90, 24, 454), + Trans(23, 108, 24, 454), + Trans(23, 116, 24, 454), + Trans(23, 117, 24, 454), + Trans(25, 5, 24, 454), + Trans(25, 12, 24, 454), + Trans(25, 14, 24, 454), + Trans(25, 16, 24, 454), + Trans(25, 17, 24, 454), + Trans(25, 18, 24, 454), + Trans(25, 19, 24, 454), + Trans(25, 20, 24, 454), + Trans(25, 21, 24, 454), + Trans(25, 22, 24, 454), + Trans(25, 23, 24, 454), + Trans(25, 24, 24, 454), + Trans(25, 25, 24, 454), + Trans(25, 26, 24, 454), + Trans(25, 31, 24, 454), + Trans(25, 32, 24, 454), + Trans(25, 33, 24, 454), + Trans(25, 34, 24, 454), + Trans(25, 40, 24, 454), + Trans(25, 43, 24, 454), + Trans(25, 44, 24, 454), + Trans(25, 45, 24, 454), + Trans(25, 46, 24, 454), + Trans(25, 47, 24, 454), + Trans(25, 48, 24, 454), + Trans(25, 52, 24, 454), + Trans(25, 96, 24, 454), + Trans(25, 105, 24, 454), + ], + k: 3, + }, + /* 30 - "ArrayLiteralListOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 32, 1, 455), Trans(0, 44, 2, 456)], + k: 1, + }, + /* 31 - "ArrayType" */ + LookaheadDFA { + prod0: 530, + transitions: &[], + k: 0, + }, + /* 32 - "ArrayTypeOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 32, 2, 532), + Trans(0, 36, 2, 532), + Trans(0, 41, 1, 531), + Trans(0, 44, 2, 532), + Trans(0, 46, 2, 532), + Trans(0, 47, 2, 532), + ], + k: 1, + }, + /* 33 - "As" */ + LookaheadDFA { + prod0: 276, + transitions: &[], + k: 0, + }, + /* 34 - "AsTerm" */ + LookaheadDFA { + prod0: 47, + transitions: &[], + k: 0, + }, + /* 35 - "AsToken" */ + LookaheadDFA { + prod0: 163, + transitions: &[], + k: 0, + }, + /* 36 - "Assign" */ + LookaheadDFA { + prod0: 277, + transitions: &[], + k: 0, + }, + /* 37 - "AssignDeclaration" */ + LookaheadDFA { + prod0: 655, + transitions: &[], + k: 0, + }, + /* 38 - "AssignTerm" */ + LookaheadDFA { + prod0: 46, + transitions: &[], + k: 0, + }, + /* 39 - "AssignToken" */ + LookaheadDFA { + prod0: 164, + transitions: &[], + k: 0, + }, + /* 40 - "Assignment" */ + LookaheadDFA { + prod0: 564, + transitions: &[], + k: 0, + }, + /* 41 - "AssignmentGroup" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 15, 2, 566), Trans(0, 36, 1, 565)], + k: 1, + }, + /* 42 - "AssignmentOperator" */ + LookaheadDFA { + prod0: 237, + transitions: &[], + k: 0, + }, + /* 43 - "AssignmentOperatorTerm" */ + LookaheadDFA { + prod0: 10, + transitions: &[], + k: 0, + }, + /* 44 - "AssignmentOperatorToken" */ + LookaheadDFA { + prod0: 124, + transitions: &[], + k: 0, + }, + /* 45 - "Attribute" */ + LookaheadDFA { + prod0: 622, + transitions: &[], + k: 0, + }, + /* 46 - "AttributeItem" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 6, 2, 631), Trans(0, 117, 1, 630)], + k: 1, + }, + /* 47 - "AttributeList" */ + LookaheadDFA { + prod0: 625, + transitions: &[], + k: 0, + }, + /* 48 - "AttributeListList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 32, 1, -1), + Trans(0, 46, 5, -1), + Trans(1, 5, 4, -1), + Trans(1, 6, 2, -1), + Trans(1, 46, 9, -1), + Trans(1, 117, 2, -1), + Trans(2, 5, 3, 626), + Trans(2, 32, 3, 626), + Trans(2, 46, 3, 626), + Trans(4, 6, 3, 626), + Trans(4, 46, 8, 627), + Trans(4, 117, 3, 626), + Trans(5, 5, 6, -1), + Trans(5, 45, 7, -1), + Trans(6, 45, 8, 627), + Trans(7, 5, 8, 627), + Trans(7, 31, 8, 627), + Trans(7, 37, 8, 627), + Trans(7, 40, 8, 627), + Trans(7, 49, 8, 627), + Trans(7, 50, 8, 627), + Trans(7, 51, 8, 627), + Trans(7, 61, 8, 627), + Trans(7, 62, 8, 627), + Trans(7, 63, 8, 627), + Trans(7, 66, 8, 627), + Trans(7, 67, 8, 627), + Trans(7, 68, 8, 627), + Trans(7, 72, 8, 627), + Trans(7, 73, 8, 627), + Trans(7, 74, 8, 627), + Trans(7, 75, 8, 627), + Trans(7, 79, 8, 627), + Trans(7, 80, 8, 627), + Trans(7, 82, 8, 627), + Trans(7, 83, 8, 627), + Trans(7, 86, 8, 627), + Trans(7, 87, 8, 627), + Trans(7, 91, 8, 627), + Trans(7, 92, 8, 627), + Trans(7, 93, 8, 627), + Trans(7, 94, 8, 627), + Trans(7, 107, 8, 627), + Trans(7, 110, 8, 627), + Trans(7, 113, 8, 627), + Trans(7, 114, 8, 627), + Trans(7, 115, 8, 627), + Trans(7, 117, 8, 627), + Trans(9, 5, 8, 627), + Trans(9, 45, 8, 627), + ], + k: 3, + }, + /* 49 - "AttributeListOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 32, 1, 628), Trans(0, 46, 2, 629)], + k: 1, + }, + /* 50 - "AttributeOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 42, 1, 623), Trans(0, 45, 2, 624)], + k: 1, + }, + /* 51 - "BackQuote" */ + LookaheadDFA { + prod0: 250, + transitions: &[], + k: 0, + }, + /* 52 - "BackQuoteTerm" */ + LookaheadDFA { + prod0: 23, + transitions: &[], + k: 0, + }, + /* 53 - "BackQuoteToken" */ + LookaheadDFA { + prod0: 137, + transitions: &[], + k: 0, + }, + /* 54 - "BaseLess" */ + LookaheadDFA { + prod0: 235, + transitions: &[], + k: 0, + }, + /* 55 - "BaseLessTerm" */ + LookaheadDFA { + prod0: 6, + transitions: &[], + k: 0, + }, + /* 56 - "BaseLessToken" */ + LookaheadDFA { + prod0: 122, + transitions: &[], + k: 0, + }, + /* 57 - "Based" */ + LookaheadDFA { + prod0: 234, + transitions: &[], + k: 0, + }, + /* 58 - "BasedTerm" */ + LookaheadDFA { + prod0: 4, + transitions: &[], + k: 0, + }, + /* 59 - "BasedToken" */ + LookaheadDFA { + prod0: 121, + transitions: &[], + k: 0, + }, + /* 60 - "Bit" */ + LookaheadDFA { + prod0: 278, + transitions: &[], + k: 0, + }, + /* 61 - "BitTerm" */ + LookaheadDFA { + prod0: 48, + transitions: &[], + k: 0, + }, + /* 62 - "BitToken" */ + LookaheadDFA { + prod0: 165, + transitions: &[], + k: 0, + }, + /* 63 - "Break" */ + LookaheadDFA { + prod0: 279, + transitions: &[], + k: 0, + }, + /* 64 - "BreakStatement" */ + LookaheadDFA { + prod0: 590, + transitions: &[], + k: 0, + }, + /* 65 - "BreakTerm" */ + LookaheadDFA { + prod0: 98, + transitions: &[], + k: 0, + }, + /* 66 - "BreakToken" */ + LookaheadDFA { + prod0: 215, + transitions: &[], + k: 0, + }, + /* 67 - "Case" */ + LookaheadDFA { + prod0: 280, + transitions: &[], + k: 0, + }, + /* 68 - "CaseCondition" */ + LookaheadDFA { + prod0: 606, + transitions: &[], + k: 0, + }, + /* 69 - "CaseConditionList" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 31, 2, 608), Trans(0, 32, 1, 607)], + k: 1, + }, + /* 70 - "CaseExpression" */ + LookaheadDFA { + prod0: 465, + transitions: &[], + k: 0, + }, + /* 71 - "CaseExpressionList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 6, 1, 466), + Trans(0, 7, 1, 466), + Trans(0, 8, 1, 466), + Trans(0, 9, 1, 466), + Trans(0, 10, 1, 466), + Trans(0, 11, 1, 466), + Trans(0, 18, 1, 466), + Trans(0, 24, 1, 466), + Trans(0, 25, 1, 466), + Trans(0, 26, 1, 466), + Trans(0, 27, 1, 466), + Trans(0, 39, 1, 466), + Trans(0, 40, 1, 466), + Trans(0, 42, 1, 466), + Trans(0, 54, 1, 466), + Trans(0, 59, 2, 467), + Trans(0, 72, 1, 466), + Trans(0, 78, 1, 466), + Trans(0, 85, 1, 466), + Trans(0, 88, 1, 466), + Trans(0, 90, 1, 466), + Trans(0, 108, 1, 466), + Trans(0, 116, 1, 466), + Trans(0, 117, 1, 466), + ], + k: 1, + }, + /* 72 - "CaseExpressionOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 32, 1, 468), Trans(0, 44, 2, 469)], + k: 1, + }, + /* 73 - "CaseItem" */ + LookaheadDFA { + prod0: 599, + transitions: &[], + k: 0, + }, + /* 74 - "CaseItemGroup" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 6, 1, 604), + Trans(0, 7, 1, 604), + Trans(0, 8, 1, 604), + Trans(0, 9, 1, 604), + Trans(0, 10, 1, 604), + Trans(0, 11, 1, 604), + Trans(0, 18, 1, 604), + Trans(0, 24, 1, 604), + Trans(0, 25, 1, 604), + Trans(0, 26, 1, 604), + Trans(0, 27, 1, 604), + Trans(0, 39, 1, 604), + Trans(0, 40, 1, 604), + Trans(0, 42, 1, 604), + Trans(0, 54, 1, 604), + Trans(0, 59, 2, 605), + Trans(0, 72, 1, 604), + Trans(0, 78, 1, 604), + Trans(0, 85, 1, 604), + Trans(0, 88, 1, 604), + Trans(0, 90, 1, 604), + Trans(0, 108, 1, 604), + Trans(0, 116, 1, 604), + Trans(0, 117, 1, 604), + ], + k: 1, + }, + /* 75 - "CaseItemGroup0" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 40, 2, 601), + Trans(0, 54, 1, 600), + Trans(0, 67, 1, 600), + Trans(0, 71, 1, 600), + Trans(0, 72, 1, 600), + Trans(0, 82, 1, 600), + Trans(0, 102, 1, 600), + Trans(0, 103, 1, 600), + Trans(0, 108, 1, 600), + Trans(0, 116, 1, 600), + Trans(0, 117, 1, 600), + ], + k: 1, + }, + /* 76 - "CaseItemGroup0List" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 44, 2, 603), + Trans(0, 54, 1, 602), + Trans(0, 67, 1, 602), + Trans(0, 71, 1, 602), + Trans(0, 72, 1, 602), + Trans(0, 82, 1, 602), + Trans(0, 102, 1, 602), + Trans(0, 103, 1, 602), + Trans(0, 108, 1, 602), + Trans(0, 116, 1, 602), + Trans(0, 117, 1, 602), + ], + k: 1, + }, + /* 77 - "CaseStatement" */ + LookaheadDFA { + prod0: 596, + transitions: &[], + k: 0, + }, + /* 78 - "CaseStatementList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 6, 1, 597), + Trans(0, 7, 1, 597), + Trans(0, 8, 1, 597), + Trans(0, 9, 1, 597), + Trans(0, 10, 1, 597), + Trans(0, 11, 1, 597), + Trans(0, 18, 1, 597), + Trans(0, 24, 1, 597), + Trans(0, 25, 1, 597), + Trans(0, 26, 1, 597), + Trans(0, 27, 1, 597), + Trans(0, 39, 1, 597), + Trans(0, 40, 1, 597), + Trans(0, 42, 1, 597), + Trans(0, 44, 2, 598), + Trans(0, 54, 1, 597), + Trans(0, 59, 1, 597), + Trans(0, 72, 1, 597), + Trans(0, 78, 1, 597), + Trans(0, 85, 1, 597), + Trans(0, 88, 1, 597), + Trans(0, 90, 1, 597), + Trans(0, 108, 1, 597), + Trans(0, 116, 1, 597), + Trans(0, 117, 1, 597), + ], + k: 1, + }, + /* 79 - "CaseTerm" */ + LookaheadDFA { + prod0: 49, + transitions: &[], + k: 0, + }, + /* 80 - "CaseToken" */ + LookaheadDFA { + prod0: 166, + transitions: &[], + k: 0, + }, + /* 81 - "CastingType" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 55, 7, 539), + Trans(0, 56, 8, 540), + Trans(0, 57, 9, 541), + Trans(0, 64, 5, 537), + Trans(0, 65, 6, 538), + Trans(0, 69, 3, 535), + Trans(0, 70, 4, 536), + Trans(0, 97, 10, 542), + Trans(0, 98, 11, 543), + Trans(0, 99, 12, 544), + Trans(0, 100, 13, 545), + Trans(0, 101, 14, 546), + Trans(0, 111, 1, 533), + Trans(0, 112, 2, 534), + Trans(0, 116, 15, 547), + Trans(0, 117, 15, 547), + ], + k: 1, + }, + /* 82 - "Clock" */ + LookaheadDFA { + prod0: 281, + transitions: &[], + k: 0, + }, + /* 83 - "ClockDomain" */ + LookaheadDFA { + prod0: 548, + transitions: &[], + k: 0, + }, + /* 84 - "ClockNegedge" */ + LookaheadDFA { + prod0: 283, + transitions: &[], + k: 0, + }, + /* 85 - "ClockNegedgeTerm" */ + LookaheadDFA { + prod0: 52, + transitions: &[], + k: 0, + }, + /* 86 - "ClockNegedgeToken" */ + LookaheadDFA { + prod0: 169, + transitions: &[], + k: 0, + }, + /* 87 - "ClockPosedge" */ + LookaheadDFA { + prod0: 282, + transitions: &[], + k: 0, + }, + /* 88 - "ClockPosedgeTerm" */ + LookaheadDFA { + prod0: 51, + transitions: &[], + k: 0, + }, + /* 89 - "ClockPosedgeToken" */ + LookaheadDFA { + prod0: 168, + transitions: &[], + k: 0, + }, + /* 90 - "ClockTerm" */ + LookaheadDFA { + prod0: 50, + transitions: &[], + k: 0, + }, + /* 91 - "ClockToken" */ + LookaheadDFA { + prod0: 167, + transitions: &[], + k: 0, + }, + /* 92 - "Colon" */ + LookaheadDFA { + prod0: 251, + transitions: &[], + k: 0, + }, + /* 93 - "ColonColon" */ + LookaheadDFA { + prod0: 253, + transitions: &[], + k: 0, + }, + /* 94 - "ColonColonLAngle" */ + LookaheadDFA { + prod0: 252, + transitions: &[], + k: 0, + }, + /* 95 - "ColonColonLAngleTerm" */ + LookaheadDFA { + prod0: 24, + transitions: &[], + k: 0, + }, + /* 96 - "ColonColonLAngleToken" */ + LookaheadDFA { + prod0: 139, + transitions: &[], + k: 0, + }, + /* 97 - "ColonColonTerm" */ + LookaheadDFA { + prod0: 25, + transitions: &[], + k: 0, + }, + /* 98 - "ColonColonToken" */ + LookaheadDFA { + prod0: 140, + transitions: &[], + k: 0, + }, + /* 99 - "ColonTerm" */ + LookaheadDFA { + prod0: 26, + transitions: &[], + k: 0, + }, + /* 100 - "ColonToken" */ + LookaheadDFA { + prod0: 138, + transitions: &[], + k: 0, + }, + /* 101 - "Comma" */ + LookaheadDFA { + prod0: 254, + transitions: &[], + k: 0, + }, + /* 102 - "CommaTerm" */ + LookaheadDFA { + prod0: 27, + transitions: &[], + k: 0, + }, + /* 103 - "CommaToken" */ + LookaheadDFA { + prod0: 141, + transitions: &[], + k: 0, + }, + /* 104 - "Comments" */ + LookaheadDFA { + prod0: 114, + transitions: &[], + k: 0, + }, + /* 105 - "CommentsOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 0, 2, 116), + Trans(0, 5, 1, 115), + Trans(0, 6, 2, 116), + Trans(0, 7, 2, 116), + Trans(0, 8, 2, 116), + Trans(0, 9, 2, 116), + Trans(0, 10, 2, 116), + Trans(0, 11, 2, 116), + Trans(0, 12, 2, 116), + Trans(0, 13, 2, 116), + Trans(0, 14, 2, 116), + Trans(0, 15, 2, 116), + Trans(0, 16, 2, 116), + Trans(0, 17, 2, 116), + Trans(0, 18, 2, 116), + Trans(0, 19, 2, 116), + Trans(0, 20, 2, 116), + Trans(0, 21, 2, 116), + Trans(0, 22, 2, 116), + Trans(0, 23, 2, 116), + Trans(0, 24, 2, 116), + Trans(0, 25, 2, 116), + Trans(0, 26, 2, 116), + Trans(0, 27, 2, 116), + Trans(0, 28, 2, 116), + Trans(0, 29, 2, 116), + Trans(0, 30, 2, 116), + Trans(0, 31, 2, 116), + Trans(0, 32, 2, 116), + Trans(0, 33, 2, 116), + Trans(0, 34, 2, 116), + Trans(0, 35, 2, 116), + Trans(0, 36, 2, 116), + Trans(0, 37, 2, 116), + Trans(0, 38, 2, 116), + Trans(0, 39, 2, 116), + Trans(0, 40, 2, 116), + Trans(0, 41, 2, 116), + Trans(0, 42, 2, 116), + Trans(0, 43, 2, 116), + Trans(0, 44, 2, 116), + Trans(0, 45, 2, 116), + Trans(0, 46, 2, 116), + Trans(0, 47, 2, 116), + Trans(0, 48, 2, 116), + Trans(0, 49, 2, 116), + Trans(0, 50, 2, 116), + Trans(0, 51, 2, 116), + Trans(0, 52, 2, 116), + Trans(0, 53, 2, 116), + Trans(0, 54, 2, 116), + Trans(0, 55, 2, 116), + Trans(0, 56, 2, 116), + Trans(0, 57, 2, 116), + Trans(0, 58, 2, 116), + Trans(0, 59, 2, 116), + Trans(0, 60, 2, 116), + Trans(0, 61, 2, 116), + Trans(0, 62, 2, 116), + Trans(0, 63, 2, 116), + Trans(0, 64, 2, 116), + Trans(0, 65, 2, 116), + Trans(0, 66, 2, 116), + Trans(0, 67, 2, 116), + Trans(0, 68, 2, 116), + Trans(0, 69, 2, 116), + Trans(0, 70, 2, 116), + Trans(0, 71, 2, 116), + Trans(0, 72, 2, 116), + Trans(0, 73, 2, 116), + Trans(0, 74, 2, 116), + Trans(0, 75, 2, 116), + Trans(0, 76, 2, 116), + Trans(0, 77, 2, 116), + Trans(0, 78, 2, 116), + Trans(0, 79, 2, 116), + Trans(0, 80, 2, 116), + Trans(0, 81, 2, 116), + Trans(0, 82, 2, 116), + Trans(0, 83, 2, 116), + Trans(0, 84, 2, 116), + Trans(0, 85, 2, 116), + Trans(0, 86, 2, 116), + Trans(0, 87, 2, 116), + Trans(0, 88, 2, 116), + Trans(0, 89, 2, 116), + Trans(0, 90, 2, 116), + Trans(0, 91, 2, 116), + Trans(0, 92, 2, 116), + Trans(0, 93, 2, 116), + Trans(0, 94, 2, 116), + Trans(0, 95, 2, 116), + Trans(0, 96, 2, 116), + Trans(0, 97, 2, 116), + Trans(0, 98, 2, 116), + Trans(0, 99, 2, 116), + Trans(0, 100, 2, 116), + Trans(0, 101, 2, 116), + Trans(0, 102, 2, 116), + Trans(0, 103, 2, 116), + Trans(0, 104, 2, 116), + Trans(0, 105, 2, 116), + Trans(0, 106, 2, 116), + Trans(0, 107, 2, 116), + Trans(0, 108, 2, 116), + Trans(0, 109, 2, 116), + Trans(0, 110, 2, 116), + Trans(0, 111, 2, 116), + Trans(0, 112, 2, 116), + Trans(0, 113, 2, 116), + Trans(0, 114, 2, 116), + Trans(0, 115, 2, 116), + Trans(0, 116, 2, 116), + Trans(0, 117, 2, 116), + ], + k: 1, + }, + /* 106 - "CommentsTerm" */ + LookaheadDFA { + prod0: 0, + transitions: &[], + k: 0, + }, + /* 107 - "ConcatenationItem" */ + LookaheadDFA { + prod0: 449, + transitions: &[], + k: 0, + }, + /* 108 - "ConcatenationItemOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 32, 2, 451), + Trans(0, 44, 2, 451), + Trans(0, 96, 1, 450), + ], + k: 1, + }, + /* 109 - "ConcatenationList" */ + LookaheadDFA { + prod0: 444, + transitions: &[], + k: 0, + }, + /* 110 - "ConcatenationListList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 32, 1, -1), + Trans(0, 44, 10, -1), + Trans(1, 5, 9, -1), + Trans(1, 6, 2, -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, 18, 4, -1), + Trans(1, 24, 4, -1), + Trans(1, 25, 4, -1), + Trans(1, 26, 4, -1), + Trans(1, 27, 4, -1), + Trans(1, 39, 5, -1), + Trans(1, 40, 4, -1), + Trans(1, 42, 4, -1), + Trans(1, 44, 24, -1), + Trans(1, 54, 4, -1), + Trans(1, 72, 4, -1), + Trans(1, 78, 4, -1), + Trans(1, 85, 2, -1), + Trans(1, 88, 2, -1), + Trans(1, 90, 4, -1), + Trans(1, 108, 6, -1), + Trans(1, 116, 7, -1), + Trans(1, 117, 8, -1), + Trans(2, 5, 3, 445), + Trans(2, 16, 3, 445), + Trans(2, 17, 3, 445), + Trans(2, 18, 3, 445), + Trans(2, 19, 3, 445), + Trans(2, 20, 3, 445), + Trans(2, 21, 3, 445), + Trans(2, 22, 3, 445), + Trans(2, 23, 3, 445), + Trans(2, 24, 3, 445), + Trans(2, 25, 3, 445), + Trans(2, 26, 3, 445), + Trans(2, 32, 3, 445), + Trans(2, 44, 3, 445), + Trans(2, 48, 3, 445), + Trans(2, 52, 3, 445), + Trans(2, 96, 3, 445), + Trans(4, 5, 3, 445), + Trans(4, 6, 3, 445), + Trans(4, 7, 3, 445), + Trans(4, 8, 3, 445), + Trans(4, 9, 3, 445), + Trans(4, 10, 3, 445), + Trans(4, 11, 3, 445), + Trans(4, 18, 3, 445), + Trans(4, 24, 3, 445), + Trans(4, 25, 3, 445), + Trans(4, 26, 3, 445), + Trans(4, 27, 3, 445), + Trans(4, 39, 3, 445), + Trans(4, 40, 3, 445), + Trans(4, 42, 3, 445), + Trans(4, 54, 3, 445), + Trans(4, 72, 3, 445), + Trans(4, 78, 3, 445), + Trans(4, 85, 3, 445), + Trans(4, 88, 3, 445), + Trans(4, 90, 3, 445), + Trans(4, 108, 3, 445), + Trans(4, 116, 3, 445), + Trans(4, 117, 3, 445), + Trans(5, 5, 3, 445), + Trans(5, 6, 3, 445), + Trans(5, 7, 3, 445), + Trans(5, 8, 3, 445), + Trans(5, 9, 3, 445), + Trans(5, 10, 3, 445), + Trans(5, 11, 3, 445), + Trans(5, 18, 3, 445), + Trans(5, 24, 3, 445), + Trans(5, 25, 3, 445), + Trans(5, 26, 3, 445), + Trans(5, 27, 3, 445), + Trans(5, 39, 3, 445), + Trans(5, 40, 3, 445), + Trans(5, 42, 3, 445), + Trans(5, 54, 3, 445), + Trans(5, 59, 3, 445), + Trans(5, 72, 3, 445), + Trans(5, 78, 3, 445), + Trans(5, 85, 3, 445), + Trans(5, 88, 3, 445), + Trans(5, 90, 3, 445), + Trans(5, 108, 3, 445), + Trans(5, 116, 3, 445), + Trans(5, 117, 3, 445), + Trans(6, 5, 3, 445), + Trans(6, 40, 3, 445), + Trans(7, 5, 3, 445), + Trans(7, 16, 3, 445), + Trans(7, 17, 3, 445), + Trans(7, 18, 3, 445), + Trans(7, 19, 3, 445), + Trans(7, 20, 3, 445), + Trans(7, 21, 3, 445), + Trans(7, 22, 3, 445), + Trans(7, 23, 3, 445), + Trans(7, 24, 3, 445), + Trans(7, 25, 3, 445), + Trans(7, 26, 3, 445), + Trans(7, 30, 3, 445), + Trans(7, 32, 3, 445), + Trans(7, 35, 3, 445), + Trans(7, 41, 3, 445), + Trans(7, 42, 3, 445), + Trans(7, 44, 3, 445), + Trans(7, 48, 3, 445), + Trans(7, 52, 3, 445), + Trans(7, 96, 3, 445), + Trans(8, 5, 3, 445), + Trans(8, 16, 3, 445), + Trans(8, 17, 3, 445), + Trans(8, 18, 3, 445), + Trans(8, 19, 3, 445), + Trans(8, 20, 3, 445), + Trans(8, 21, 3, 445), + Trans(8, 22, 3, 445), + Trans(8, 23, 3, 445), + Trans(8, 24, 3, 445), + Trans(8, 25, 3, 445), + Trans(8, 26, 3, 445), + Trans(8, 29, 3, 445), + Trans(8, 30, 3, 445), + Trans(8, 32, 3, 445), + Trans(8, 35, 3, 445), + Trans(8, 41, 3, 445), + Trans(8, 42, 3, 445), + Trans(8, 44, 3, 445), + Trans(8, 48, 3, 445), + Trans(8, 52, 3, 445), + Trans(8, 96, 3, 445), + Trans(9, 6, 3, 445), + Trans(9, 7, 3, 445), + Trans(9, 8, 3, 445), + Trans(9, 9, 3, 445), + Trans(9, 10, 3, 445), + Trans(9, 11, 3, 445), + Trans(9, 18, 3, 445), + Trans(9, 24, 3, 445), + Trans(9, 25, 3, 445), + Trans(9, 26, 3, 445), + Trans(9, 27, 3, 445), + Trans(9, 39, 3, 445), + Trans(9, 40, 3, 445), + Trans(9, 42, 3, 445), + Trans(9, 44, 23, 446), + Trans(9, 54, 3, 445), + Trans(9, 72, 3, 445), + Trans(9, 78, 3, 445), + Trans(9, 85, 3, 445), + Trans(9, 88, 3, 445), + Trans(9, 90, 3, 445), + Trans(9, 108, 3, 445), + Trans(9, 116, 3, 445), + Trans(9, 117, 3, 445), + 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, 31, 13, -1), + Trans(10, 32, 14, -1), + Trans(10, 33, 12, -1), + Trans(10, 34, 12, -1), + Trans(10, 40, 15, -1), + Trans(10, 43, 16, -1), + Trans(10, 44, 17, -1), + Trans(10, 45, 18, -1), + Trans(10, 46, 19, -1), + Trans(10, 47, 20, -1), + Trans(10, 48, 12, -1), + Trans(10, 52, 21, -1), + Trans(10, 96, 12, -1), + Trans(10, 105, 22, -1), + Trans(11, 12, 23, 446), + Trans(11, 14, 23, 446), + Trans(11, 16, 23, 446), + Trans(11, 17, 23, 446), + Trans(11, 18, 23, 446), + Trans(11, 19, 23, 446), + Trans(11, 20, 23, 446), + Trans(11, 21, 23, 446), + Trans(11, 22, 23, 446), + Trans(11, 23, 23, 446), + Trans(11, 24, 23, 446), + Trans(11, 25, 23, 446), + Trans(11, 26, 23, 446), + Trans(11, 31, 23, 446), + Trans(11, 32, 23, 446), + Trans(11, 33, 23, 446), + Trans(11, 34, 23, 446), + Trans(11, 40, 23, 446), + Trans(11, 43, 23, 446), + Trans(11, 44, 23, 446), + Trans(11, 45, 23, 446), + Trans(11, 46, 23, 446), + Trans(11, 47, 23, 446), + Trans(11, 48, 23, 446), + Trans(11, 52, 23, 446), + Trans(11, 96, 23, 446), + Trans(11, 105, 23, 446), + Trans(12, 5, 23, 446), + Trans(12, 6, 23, 446), + Trans(12, 7, 23, 446), + Trans(12, 8, 23, 446), + Trans(12, 9, 23, 446), + Trans(12, 10, 23, 446), + Trans(12, 11, 23, 446), + Trans(12, 18, 23, 446), + Trans(12, 24, 23, 446), + Trans(12, 25, 23, 446), + Trans(12, 26, 23, 446), + Trans(12, 27, 23, 446), + Trans(12, 39, 23, 446), + Trans(12, 40, 23, 446), + Trans(12, 42, 23, 446), + Trans(12, 54, 23, 446), + Trans(12, 72, 23, 446), + Trans(12, 78, 23, 446), + Trans(12, 85, 23, 446), + Trans(12, 88, 23, 446), + Trans(12, 90, 23, 446), + Trans(12, 108, 23, 446), + Trans(12, 116, 23, 446), + Trans(12, 117, 23, 446), + Trans(13, 5, 23, 446), + Trans(13, 6, 23, 446), + Trans(13, 7, 23, 446), + Trans(13, 8, 23, 446), + Trans(13, 9, 23, 446), + Trans(13, 10, 23, 446), + Trans(13, 11, 23, 446), + Trans(13, 18, 23, 446), + Trans(13, 24, 23, 446), + Trans(13, 25, 23, 446), + Trans(13, 26, 23, 446), + Trans(13, 27, 23, 446), + Trans(13, 39, 23, 446), + Trans(13, 40, 23, 446), + Trans(13, 42, 23, 446), + Trans(13, 54, 23, 446), + Trans(13, 67, 23, 446), + Trans(13, 71, 23, 446), + Trans(13, 72, 23, 446), + Trans(13, 78, 23, 446), + Trans(13, 82, 23, 446), + Trans(13, 85, 23, 446), + Trans(13, 88, 23, 446), + Trans(13, 90, 23, 446), + Trans(13, 102, 23, 446), + Trans(13, 103, 23, 446), + Trans(13, 108, 23, 446), + Trans(13, 116, 23, 446), + Trans(13, 117, 23, 446), + Trans(14, 5, 23, 446), + Trans(14, 6, 23, 446), + Trans(14, 7, 23, 446), + Trans(14, 8, 23, 446), + Trans(14, 9, 23, 446), + Trans(14, 10, 23, 446), + Trans(14, 11, 23, 446), + Trans(14, 18, 23, 446), + Trans(14, 24, 23, 446), + Trans(14, 25, 23, 446), + Trans(14, 26, 23, 446), + Trans(14, 27, 23, 446), + Trans(14, 37, 23, 446), + Trans(14, 39, 23, 446), + Trans(14, 40, 23, 446), + Trans(14, 42, 23, 446), + Trans(14, 44, 23, 446), + Trans(14, 46, 23, 446), + Trans(14, 54, 23, 446), + Trans(14, 59, 23, 446), + Trans(14, 72, 23, 446), + Trans(14, 78, 23, 446), + Trans(14, 83, 23, 446), + Trans(14, 85, 23, 446), + Trans(14, 88, 23, 446), + Trans(14, 90, 23, 446), + Trans(14, 92, 23, 446), + Trans(14, 108, 23, 446), + Trans(14, 116, 23, 446), + Trans(14, 117, 23, 446), + Trans(15, 5, 23, 446), + Trans(15, 6, 23, 446), + Trans(15, 7, 23, 446), + Trans(15, 8, 23, 446), + Trans(15, 9, 23, 446), + Trans(15, 10, 23, 446), + Trans(15, 11, 23, 446), + Trans(15, 18, 23, 446), + Trans(15, 24, 23, 446), + Trans(15, 25, 23, 446), + Trans(15, 26, 23, 446), + Trans(15, 27, 23, 446), + Trans(15, 31, 23, 446), + Trans(15, 37, 23, 446), + Trans(15, 39, 23, 446), + Trans(15, 40, 23, 446), + Trans(15, 42, 23, 446), + Trans(15, 44, 23, 446), + Trans(15, 49, 23, 446), + Trans(15, 50, 23, 446), + Trans(15, 51, 23, 446), + Trans(15, 54, 23, 446), + Trans(15, 59, 23, 446), + Trans(15, 62, 23, 446), + Trans(15, 66, 23, 446), + Trans(15, 67, 23, 446), + Trans(15, 68, 23, 446), + Trans(15, 71, 23, 446), + Trans(15, 72, 23, 446), + Trans(15, 73, 23, 446), + Trans(15, 75, 23, 446), + Trans(15, 78, 23, 446), + Trans(15, 79, 23, 446), + Trans(15, 82, 23, 446), + Trans(15, 83, 23, 446), + Trans(15, 85, 23, 446), + Trans(15, 86, 23, 446), + Trans(15, 88, 23, 446), + Trans(15, 90, 23, 446), + Trans(15, 102, 23, 446), + Trans(15, 103, 23, 446), + Trans(15, 107, 23, 446), + Trans(15, 108, 23, 446), + Trans(15, 110, 23, 446), + Trans(15, 113, 23, 446), + Trans(15, 114, 23, 446), + Trans(15, 115, 23, 446), + Trans(15, 116, 23, 446), + Trans(15, 117, 23, 446), + Trans(16, 5, 23, 446), + Trans(16, 32, 23, 446), + Trans(16, 36, 23, 446), + Trans(16, 40, 23, 446), + Trans(16, 41, 23, 446), + Trans(16, 44, 23, 446), + Trans(16, 46, 23, 446), + Trans(16, 47, 23, 446), + Trans(16, 81, 23, 446), + Trans(17, 5, 23, 446), + Trans(17, 12, 23, 446), + Trans(17, 14, 23, 446), + Trans(17, 16, 23, 446), + Trans(17, 17, 23, 446), + Trans(17, 18, 23, 446), + Trans(17, 19, 23, 446), + Trans(17, 20, 23, 446), + Trans(17, 21, 23, 446), + Trans(17, 22, 23, 446), + Trans(17, 23, 23, 446), + Trans(17, 24, 23, 446), + Trans(17, 25, 23, 446), + Trans(17, 26, 23, 446), + Trans(17, 31, 23, 446), + Trans(17, 32, 23, 446), + Trans(17, 33, 23, 446), + Trans(17, 34, 23, 446), + Trans(17, 37, 23, 446), + Trans(17, 40, 23, 446), + Trans(17, 43, 23, 446), + Trans(17, 44, 23, 446), + Trans(17, 45, 23, 446), + Trans(17, 46, 23, 446), + Trans(17, 47, 23, 446), + Trans(17, 48, 23, 446), + Trans(17, 49, 23, 446), + Trans(17, 50, 23, 446), + Trans(17, 51, 23, 446), + Trans(17, 52, 23, 446), + Trans(17, 60, 23, 446), + Trans(17, 62, 23, 446), + Trans(17, 63, 23, 446), + Trans(17, 66, 23, 446), + Trans(17, 67, 23, 446), + Trans(17, 68, 23, 446), + Trans(17, 72, 23, 446), + Trans(17, 73, 23, 446), + Trans(17, 75, 23, 446), + Trans(17, 79, 23, 446), + Trans(17, 82, 23, 446), + Trans(17, 83, 23, 446), + Trans(17, 86, 23, 446), + Trans(17, 96, 23, 446), + Trans(17, 105, 23, 446), + Trans(17, 107, 23, 446), + Trans(17, 110, 23, 446), + Trans(17, 113, 23, 446), + Trans(17, 114, 23, 446), + Trans(17, 115, 23, 446), + Trans(18, 5, 23, 446), + Trans(18, 12, 23, 446), + Trans(18, 14, 23, 446), + Trans(18, 15, 23, 446), + Trans(18, 16, 23, 446), + Trans(18, 17, 23, 446), + Trans(18, 18, 23, 446), + Trans(18, 19, 23, 446), + Trans(18, 20, 23, 446), + Trans(18, 21, 23, 446), + Trans(18, 22, 23, 446), + Trans(18, 23, 23, 446), + Trans(18, 24, 23, 446), + Trans(18, 25, 23, 446), + Trans(18, 26, 23, 446), + Trans(18, 31, 23, 446), + Trans(18, 32, 23, 446), + Trans(18, 33, 23, 446), + Trans(18, 34, 23, 446), + Trans(18, 35, 23, 446), + Trans(18, 36, 23, 446), + Trans(18, 37, 23, 446), + Trans(18, 40, 23, 446), + Trans(18, 41, 23, 446), + Trans(18, 42, 23, 446), + Trans(18, 43, 23, 446), + Trans(18, 44, 23, 446), + Trans(18, 45, 23, 446), + Trans(18, 46, 23, 446), + Trans(18, 47, 23, 446), + Trans(18, 48, 23, 446), + Trans(18, 52, 23, 446), + Trans(18, 96, 23, 446), + Trans(18, 105, 23, 446), + Trans(19, 5, 23, 446), + Trans(19, 12, 23, 446), + Trans(19, 14, 23, 446), + Trans(19, 16, 23, 446), + Trans(19, 17, 23, 446), + Trans(19, 18, 23, 446), + Trans(19, 19, 23, 446), + Trans(19, 20, 23, 446), + Trans(19, 21, 23, 446), + Trans(19, 22, 23, 446), + Trans(19, 23, 23, 446), + Trans(19, 24, 23, 446), + Trans(19, 25, 23, 446), + Trans(19, 26, 23, 446), + Trans(19, 31, 23, 446), + Trans(19, 32, 23, 446), + Trans(19, 33, 23, 446), + Trans(19, 34, 23, 446), + Trans(19, 40, 23, 446), + Trans(19, 42, 23, 446), + Trans(19, 43, 23, 446), + Trans(19, 44, 23, 446), + Trans(19, 45, 23, 446), + Trans(19, 46, 23, 446), + Trans(19, 47, 23, 446), + Trans(19, 48, 23, 446), + Trans(19, 52, 23, 446), + Trans(19, 96, 23, 446), + Trans(19, 105, 23, 446), + Trans(20, 5, 23, 446), + Trans(20, 6, 23, 446), + Trans(20, 7, 23, 446), + Trans(20, 8, 23, 446), + Trans(20, 9, 23, 446), + Trans(20, 10, 23, 446), + Trans(20, 11, 23, 446), + Trans(20, 18, 23, 446), + Trans(20, 24, 23, 446), + Trans(20, 25, 23, 446), + Trans(20, 26, 23, 446), + Trans(20, 27, 23, 446), + Trans(20, 31, 23, 446), + Trans(20, 37, 23, 446), + Trans(20, 39, 23, 446), + Trans(20, 40, 23, 446), + Trans(20, 42, 23, 446), + Trans(20, 44, 23, 446), + Trans(20, 49, 23, 446), + Trans(20, 50, 23, 446), + Trans(20, 51, 23, 446), + Trans(20, 54, 23, 446), + Trans(20, 59, 23, 446), + Trans(20, 62, 23, 446), + Trans(20, 63, 23, 446), + Trans(20, 66, 23, 446), + Trans(20, 67, 23, 446), + Trans(20, 68, 23, 446), + Trans(20, 71, 23, 446), + Trans(20, 72, 23, 446), + Trans(20, 73, 23, 446), + Trans(20, 75, 23, 446), + Trans(20, 78, 23, 446), + Trans(20, 79, 23, 446), + Trans(20, 82, 23, 446), + Trans(20, 83, 23, 446), + Trans(20, 85, 23, 446), + Trans(20, 86, 23, 446), + Trans(20, 88, 23, 446), + Trans(20, 90, 23, 446), + Trans(20, 102, 23, 446), + Trans(20, 103, 23, 446), + Trans(20, 107, 23, 446), + Trans(20, 108, 23, 446), + Trans(20, 110, 23, 446), + Trans(20, 113, 23, 446), + Trans(20, 114, 23, 446), + Trans(20, 115, 23, 446), + Trans(20, 116, 23, 446), + Trans(20, 117, 23, 446), + Trans(21, 5, 23, 446), + Trans(21, 55, 23, 446), + Trans(21, 56, 23, 446), + Trans(21, 57, 23, 446), + Trans(21, 64, 23, 446), + Trans(21, 65, 23, 446), + Trans(21, 69, 23, 446), + Trans(21, 70, 23, 446), + Trans(21, 97, 23, 446), + Trans(21, 98, 23, 446), + Trans(21, 99, 23, 446), + Trans(21, 100, 23, 446), + Trans(21, 101, 23, 446), + Trans(21, 111, 23, 446), + Trans(21, 112, 23, 446), + Trans(21, 116, 23, 446), + Trans(21, 117, 23, 446), + Trans(22, 5, 23, 446), + Trans(22, 6, 23, 446), + Trans(22, 7, 23, 446), + Trans(22, 8, 23, 446), + Trans(22, 9, 23, 446), + Trans(22, 10, 23, 446), + Trans(22, 11, 23, 446), + Trans(22, 15, 23, 446), + Trans(22, 18, 23, 446), + Trans(22, 24, 23, 446), + Trans(22, 25, 23, 446), + Trans(22, 26, 23, 446), + Trans(22, 27, 23, 446), + Trans(22, 39, 23, 446), + Trans(22, 40, 23, 446), + Trans(22, 42, 23, 446), + Trans(22, 54, 23, 446), + Trans(22, 72, 23, 446), + Trans(22, 78, 23, 446), + Trans(22, 85, 23, 446), + Trans(22, 88, 23, 446), + Trans(22, 90, 23, 446), + Trans(22, 108, 23, 446), + Trans(22, 116, 23, 446), + Trans(22, 117, 23, 446), + Trans(24, 5, 23, 446), + Trans(24, 12, 23, 446), + Trans(24, 14, 23, 446), + Trans(24, 16, 23, 446), + Trans(24, 17, 23, 446), + Trans(24, 18, 23, 446), + Trans(24, 19, 23, 446), + Trans(24, 20, 23, 446), + Trans(24, 21, 23, 446), + Trans(24, 22, 23, 446), + Trans(24, 23, 23, 446), + Trans(24, 24, 23, 446), + Trans(24, 25, 23, 446), + Trans(24, 26, 23, 446), + Trans(24, 31, 23, 446), + Trans(24, 32, 23, 446), + Trans(24, 33, 23, 446), + Trans(24, 34, 23, 446), + Trans(24, 40, 23, 446), + Trans(24, 43, 23, 446), + Trans(24, 44, 23, 446), + Trans(24, 45, 23, 446), + Trans(24, 46, 23, 446), + Trans(24, 47, 23, 446), + Trans(24, 48, 23, 446), + Trans(24, 52, 23, 446), + Trans(24, 96, 23, 446), + Trans(24, 105, 23, 446), ], k: 3, }, /* 111 - "ConcatenationListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 441), Trans(0, 44, 2, 442)], + transitions: &[Trans(0, 32, 1, 447), Trans(0, 44, 2, 448)], k: 1, }, - /* 112 - "Defaul" */ + /* 112 - "Const" */ LookaheadDFA { - prod0: 280, + prod0: 284, transitions: &[], k: 0, }, - /* 113 - "DefaultTerm" */ + /* 113 - "ConstTerm" */ LookaheadDFA { prod0: 53, transitions: &[], k: 0, }, - /* 114 - "DefaultToken" */ + /* 114 - "ConstToken" */ LookaheadDFA { - prod0: 168, + prod0: 170, transitions: &[], k: 0, }, - /* 115 - "DescriptionGroup" */ + /* 115 - "Defaul" */ LookaheadDFA { - prod0: 960, + prod0: 285, + transitions: &[], + k: 0, + }, + /* 116 - "DefaultTerm" */ + LookaheadDFA { + prod0: 54, + transitions: &[], + k: 0, + }, + /* 117 - "DefaultToken" */ + LookaheadDFA { + prod0: 171, + transitions: &[], + k: 0, + }, + /* 118 - "DescriptionGroup" */ + LookaheadDFA { + prod0: 977, transitions: &[], k: 0, }, - /* 116 - "DescriptionGroupGroup" */ + /* 119 - "DescriptionGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 40, 1, 961), - Trans(0, 60, 2, 964), - Trans(0, 72, 2, 964), - Trans(0, 73, 2, 964), - Trans(0, 79, 2, 964), - Trans(0, 86, 2, 964), - Trans(0, 90, 2, 964), - Trans(0, 92, 2, 964), + Trans(0, 40, 1, 978), + Trans(0, 61, 2, 981), + Trans(0, 73, 2, 981), + Trans(0, 74, 2, 981), + Trans(0, 80, 2, 981), + Trans(0, 87, 2, 981), + Trans(0, 91, 2, 981), + Trans(0, 93, 2, 981), + Trans(0, 94, 2, 981), ], k: 1, }, - /* 117 - "DescriptionGroupGroupList" */ + /* 120 - "DescriptionGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 962), - Trans(0, 40, 1, 962), - Trans(0, 44, 2, 963), - Trans(0, 60, 1, 962), - Trans(0, 72, 1, 962), - Trans(0, 73, 1, 962), - Trans(0, 79, 1, 962), - Trans(0, 86, 1, 962), - Trans(0, 90, 1, 962), - Trans(0, 92, 1, 962), + Trans(0, 37, 1, 979), + Trans(0, 40, 1, 979), + Trans(0, 44, 2, 980), + Trans(0, 61, 1, 979), + Trans(0, 73, 1, 979), + Trans(0, 74, 1, 979), + Trans(0, 80, 1, 979), + Trans(0, 87, 1, 979), + Trans(0, 91, 1, 979), + Trans(0, 93, 1, 979), + Trans(0, 94, 1, 979), ], k: 1, }, - /* 118 - "DescriptionGroupList" */ + /* 121 - "DescriptionGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 965), - Trans(0, 40, 2, 966), - Trans(0, 60, 2, 966), - Trans(0, 72, 2, 966), - Trans(0, 73, 2, 966), - Trans(0, 79, 2, 966), - Trans(0, 86, 2, 966), - Trans(0, 90, 2, 966), - Trans(0, 92, 2, 966), + Trans(0, 37, 1, 982), + Trans(0, 40, 2, 983), + Trans(0, 61, 2, 983), + Trans(0, 73, 2, 983), + Trans(0, 74, 2, 983), + Trans(0, 80, 2, 983), + Trans(0, 87, 2, 983), + Trans(0, 91, 2, 983), + Trans(0, 93, 2, 983), + Trans(0, 94, 2, 983), ], k: 1, }, - /* 119 - "DescriptionItem" */ + /* 122 - "DescriptionItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 60, 23, -1), - Trans(0, 72, 18, -1), - Trans(0, 73, 27, -1), - Trans(0, 79, 8, -1), - Trans(0, 86, 4, -1), - Trans(0, 90, 13, -1), - Trans(0, 92, 1, -1), + Trans(0, 61, 28, -1), + Trans(0, 73, 23, -1), + Trans(0, 74, 32, -1), + Trans(0, 80, 8, -1), + Trans(0, 87, 4, -1), + Trans(0, 91, 13, -1), + Trans(0, 93, 18, -1), + Trans(0, 94, 1, -1), Trans(1, 5, 6, -1), - Trans(1, 79, 9, -1), - Trans(1, 86, 2, -1), - Trans(1, 90, 14, -1), - Trans(2, 5, 3, 967), - Trans(2, 115, 3, 967), + Trans(1, 80, 9, -1), + Trans(1, 87, 2, -1), + Trans(1, 91, 14, -1), + Trans(1, 93, 22, -1), + Trans(2, 5, 3, 984), + Trans(2, 117, 3, 984), Trans(4, 5, 7, -1), - Trans(4, 115, 5, -1), - Trans(5, 5, 3, 967), - Trans(5, 29, 3, 967), - Trans(5, 37, 3, 967), - Trans(5, 40, 3, 967), - Trans(5, 42, 3, 967), - Trans(6, 79, 10, 968), - Trans(6, 86, 3, 967), - Trans(6, 90, 15, 969), - Trans(7, 115, 3, 967), + Trans(4, 117, 5, -1), + Trans(5, 5, 3, 984), + Trans(5, 29, 3, 984), + Trans(5, 37, 3, 984), + Trans(5, 40, 3, 984), + Trans(5, 42, 3, 984), + Trans(5, 67, 3, 984), + Trans(6, 80, 10, 985), + Trans(6, 87, 3, 984), + Trans(6, 91, 15, 986), + Trans(6, 93, 21, 987), + Trans(7, 117, 3, 984), Trans(8, 5, 11, -1), - Trans(8, 115, 12, -1), - Trans(9, 5, 10, 968), - Trans(9, 115, 10, 968), - Trans(11, 115, 10, 968), - Trans(12, 5, 10, 968), - Trans(12, 29, 10, 968), - Trans(12, 37, 10, 968), - Trans(12, 40, 10, 968), + Trans(8, 117, 12, -1), + Trans(9, 5, 10, 985), + Trans(9, 117, 10, 985), + Trans(11, 117, 10, 985), + Trans(12, 5, 10, 985), + Trans(12, 29, 10, 985), + Trans(12, 37, 10, 985), + Trans(12, 40, 10, 985), Trans(13, 5, 16, -1), - Trans(13, 115, 17, -1), - Trans(14, 5, 15, 969), - Trans(14, 115, 15, 969), - Trans(16, 115, 15, 969), - Trans(17, 5, 15, 969), - Trans(17, 29, 15, 969), - Trans(17, 40, 15, 969), + Trans(13, 117, 17, -1), + Trans(14, 5, 15, 986), + Trans(14, 117, 15, 986), + Trans(16, 117, 15, 986), + Trans(17, 5, 15, 986), + Trans(17, 29, 15, 986), + Trans(17, 40, 15, 986), Trans(18, 5, 19, -1), - Trans(18, 114, 20, -1), - Trans(18, 115, 21, -1), - Trans(19, 114, 22, 970), - Trans(19, 115, 22, 970), - Trans(20, 5, 22, 970), - Trans(20, 30, 22, 970), - Trans(20, 47, 22, 970), - Trans(21, 5, 22, 970), - Trans(21, 29, 22, 970), - Trans(21, 30, 22, 970), - Trans(21, 47, 22, 970), + Trans(18, 87, 20, -1), + Trans(19, 87, 21, 987), + Trans(20, 5, 21, 987), + Trans(20, 117, 21, 987), + Trans(22, 5, 21, 987), + Trans(22, 87, 21, 987), Trans(23, 5, 24, -1), - Trans(23, 42, 25, -1), - Trans(24, 42, 26, 971), - Trans(25, 5, 26, 971), - Trans(25, 115, 26, 971), - Trans(27, 5, 28, -1), - Trans(27, 42, 29, -1), - Trans(28, 42, 30, 972), - Trans(29, 5, 30, 972), - Trans(29, 115, 30, 972), + Trans(23, 116, 25, -1), + Trans(23, 117, 26, -1), + Trans(24, 116, 27, 988), + Trans(24, 117, 27, 988), + Trans(25, 5, 27, 988), + Trans(25, 30, 27, 988), + Trans(25, 47, 27, 988), + Trans(26, 5, 27, 988), + Trans(26, 29, 27, 988), + Trans(26, 30, 27, 988), + Trans(26, 47, 27, 988), + Trans(28, 5, 29, -1), + Trans(28, 42, 30, -1), + Trans(29, 42, 31, 989), + Trans(30, 5, 31, 989), + Trans(30, 117, 31, 989), + Trans(32, 5, 33, -1), + Trans(32, 42, 34, -1), + Trans(33, 42, 35, 990), + Trans(34, 5, 35, 990), + Trans(34, 117, 35, 990), ], k: 3, }, - /* 120 - "Direction" */ + /* 123 - "Direction" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 72, 6, 805), - Trans(0, 75, 3, 802), - Trans(0, 76, 1, 800), - Trans(0, 85, 5, 804), - Trans(0, 88, 2, 801), - Trans(0, 93, 4, 803), + Trans(0, 73, 6, 813), + Trans(0, 76, 3, 810), + Trans(0, 77, 1, 808), + Trans(0, 86, 5, 812), + Trans(0, 89, 2, 809), + Trans(0, 95, 4, 811), ], k: 1, }, - /* 121 - "DollarIdentifier" */ + /* 124 - "DollarIdentifier" */ LookaheadDFA { - prod0: 335, + prod0: 341, transitions: &[], k: 0, }, - /* 122 - "DollarIdentifierTerm" */ + /* 125 - "DollarIdentifierTerm" */ LookaheadDFA { - prod0: 109, + prod0: 111, transitions: &[], k: 0, }, - /* 123 - "DollarIdentifierToken" */ + /* 126 - "DollarIdentifierToken" */ LookaheadDFA { - prod0: 224, + prod0: 228, transitions: &[], k: 0, }, - /* 124 - "Dot" */ + /* 127 - "Dot" */ LookaheadDFA { - prod0: 253, + prod0: 257, transitions: &[], k: 0, }, - /* 125 - "DotDot" */ + /* 128 - "DotDot" */ LookaheadDFA { - prod0: 251, + prod0: 255, transitions: &[], k: 0, }, - /* 126 - "DotDotEqu" */ + /* 129 - "DotDotEqu" */ LookaheadDFA { - prod0: 252, + prod0: 256, transitions: &[], k: 0, }, - /* 127 - "DotDotEquTerm" */ + /* 130 - "DotDotEquTerm" */ LookaheadDFA { prod0: 28, transitions: &[], k: 0, }, - /* 128 - "DotDotEquToken" */ + /* 131 - "DotDotEquToken" */ LookaheadDFA { - prod0: 141, + prod0: 143, transitions: &[], k: 0, }, - /* 129 - "DotDotTerm" */ + /* 132 - "DotDotTerm" */ LookaheadDFA { prod0: 29, transitions: &[], k: 0, }, - /* 130 - "DotDotToken" */ + /* 133 - "DotDotToken" */ LookaheadDFA { - prod0: 140, + prod0: 142, transitions: &[], k: 0, }, - /* 131 - "DotTerm" */ + /* 134 - "DotTerm" */ LookaheadDFA { prod0: 30, transitions: &[], k: 0, }, - /* 132 - "DotToken" */ + /* 135 - "DotToken" */ LookaheadDFA { - prod0: 142, + prod0: 144, transitions: &[], k: 0, }, - /* 133 - "Else" */ + /* 136 - "Else" */ LookaheadDFA { - prod0: 281, + prod0: 286, transitions: &[], k: 0, }, - /* 134 - "ElseTerm" */ + /* 137 - "ElseTerm" */ LookaheadDFA { - prod0: 54, + prod0: 55, transitions: &[], k: 0, }, - /* 135 - "ElseToken" */ + /* 138 - "ElseToken" */ LookaheadDFA { - prod0: 169, + prod0: 172, transitions: &[], k: 0, }, - /* 136 - "Embed" */ + /* 139 - "Embed" */ LookaheadDFA { - prod0: 282, + prod0: 287, transitions: &[], k: 0, }, - /* 137 - "EmbedContent" */ + /* 140 - "EmbedContent" */ LookaheadDFA { - prod0: 951, + prod0: 968, transitions: &[], k: 0, }, - /* 138 - "EmbedContentToken" */ + /* 141 - "EmbedContentToken" */ LookaheadDFA { - prod0: 952, + prod0: 969, transitions: &[], k: 0, }, - /* 139 - "EmbedContentTokenList" */ + /* 142 - "EmbedContentTokenList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 40, 1, 953), - Trans(0, 44, 2, 954), - Trans(0, 116, 1, 953), + Trans(0, 40, 1, 970), + Trans(0, 44, 2, 971), + Trans(0, 118, 1, 970), ], k: 1, }, - /* 140 - "EmbedDeclaration" */ + /* 143 - "EmbedDeclaration" */ LookaheadDFA { - prod0: 950, + prod0: 967, transitions: &[], k: 0, }, - /* 141 - "EmbedItem" */ + /* 144 - "EmbedItem" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 955), Trans(0, 116, 2, 958)], + transitions: &[Trans(0, 40, 1, 972), Trans(0, 118, 2, 975)], k: 1, }, - /* 142 - "EmbedItemList" */ + /* 145 - "EmbedItemList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 40, 1, 956), - Trans(0, 44, 2, 957), - Trans(0, 116, 1, 956), + Trans(0, 40, 1, 973), + Trans(0, 44, 2, 974), + Trans(0, 118, 1, 973), ], k: 1, }, - /* 143 - "EmbedTerm" */ + /* 146 - "EmbedTerm" */ LookaheadDFA { - prod0: 55, + prod0: 56, transitions: &[], k: 0, }, - /* 144 - "EmbedToken" */ + /* 147 - "EmbedToken" */ LookaheadDFA { - prod0: 170, + prod0: 173, transitions: &[], k: 0, }, - /* 145 - "Enum" */ + /* 148 - "Enum" */ LookaheadDFA { - prod0: 283, + prod0: 288, transitions: &[], k: 0, }, - /* 146 - "EnumDeclaration" */ + /* 149 - "EnumDeclaration" */ LookaheadDFA { - prod0: 663, + prod0: 668, transitions: &[], k: 0, }, - /* 147 - "EnumDeclarationOpt" */ + /* 150 - "EnumDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 31, 1, 664), Trans(0, 40, 2, 665)], + transitions: &[Trans(0, 31, 1, 669), Trans(0, 40, 2, 670)], k: 1, }, - /* 148 - "EnumGroup" */ + /* 151 - "EnumGroup" */ LookaheadDFA { - prod0: 671, + prod0: 676, transitions: &[], k: 0, }, - /* 149 - "EnumGroupGroup" */ + /* 152 - "EnumGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 672), Trans(0, 115, 2, 673)], + transitions: &[Trans(0, 40, 1, 677), Trans(0, 117, 2, 678)], k: 1, }, - /* 150 - "EnumGroupList" */ + /* 153 - "EnumGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 674), - Trans(0, 40, 2, 675), - Trans(0, 115, 2, 675), + Trans(0, 37, 1, 679), + Trans(0, 40, 2, 680), + Trans(0, 117, 2, 680), ], k: 1, }, - /* 151 - "EnumItem" */ + /* 154 - "EnumItem" */ LookaheadDFA { - prod0: 676, + prod0: 681, transitions: &[], k: 0, }, - /* 152 - "EnumItemOpt" */ + /* 155 - "EnumItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 2, 678), - Trans(0, 36, 1, 677), - Trans(0, 44, 2, 678), + Trans(0, 32, 2, 683), + Trans(0, 36, 1, 682), + Trans(0, 44, 2, 683), ], k: 1, }, - /* 153 - "EnumList" */ + /* 156 - "EnumList" */ LookaheadDFA { - prod0: 666, + prod0: 671, transitions: &[], k: 0, }, - /* 154 - "EnumListList" */ + /* 157 - "EnumListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -4358,21 +4412,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 37, 2, -1), Trans(1, 40, 4, -1), Trans(1, 44, 21, -1), - Trans(1, 115, 5, -1), - Trans(2, 5, 3, 667), - Trans(2, 41, 3, 667), - Trans(4, 5, 3, 667), - Trans(4, 37, 3, 667), - Trans(4, 40, 3, 667), - Trans(4, 115, 3, 667), - Trans(5, 5, 3, 667), - Trans(5, 32, 3, 667), - Trans(5, 36, 3, 667), - Trans(5, 44, 3, 667), - Trans(6, 37, 3, 667), - Trans(6, 40, 3, 667), - Trans(6, 44, 20, 668), - Trans(6, 115, 3, 667), + Trans(1, 117, 5, -1), + Trans(2, 5, 3, 672), + Trans(2, 41, 3, 672), + Trans(4, 5, 3, 672), + Trans(4, 37, 3, 672), + Trans(4, 40, 3, 672), + Trans(4, 117, 3, 672), + Trans(5, 5, 3, 672), + Trans(5, 32, 3, 672), + Trans(5, 36, 3, 672), + Trans(5, 44, 3, 672), + Trans(6, 37, 3, 672), + Trans(6, 40, 3, 672), + Trans(6, 44, 20, 673), + Trans(6, 117, 3, 672), Trans(7, 5, 8, -1), Trans(7, 31, 9, -1), Trans(7, 32, 10, -1), @@ -4382,358 +4436,298 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(7, 49, 14, -1), Trans(7, 50, 15, -1), Trans(7, 51, 9, -1), - Trans(7, 61, 9, -1), - Trans(7, 62, 16, -1), - Trans(7, 65, 14, -1), - Trans(7, 66, 9, -1), + Trans(7, 62, 9, -1), + Trans(7, 63, 16, -1), + Trans(7, 66, 14, -1), Trans(7, 67, 9, -1), - Trans(7, 71, 17, -1), - Trans(7, 72, 18, -1), - Trans(7, 74, 14, -1), - Trans(7, 78, 9, -1), - Trans(7, 81, 9, -1), + Trans(7, 68, 9, -1), + Trans(7, 72, 17, -1), + Trans(7, 73, 18, -1), + Trans(7, 75, 14, -1), + Trans(7, 79, 9, -1), Trans(7, 82, 9, -1), - Trans(7, 85, 9, -1), - Trans(7, 105, 9, -1), - Trans(7, 108, 9, -1), - Trans(7, 111, 9, -1), - Trans(7, 112, 19, -1), + Trans(7, 83, 9, -1), + Trans(7, 86, 9, -1), + Trans(7, 107, 9, -1), + Trans(7, 110, 9, -1), Trans(7, 113, 9, -1), - Trans(8, 31, 20, 668), - Trans(8, 32, 20, 668), - Trans(8, 37, 20, 668), - Trans(8, 40, 20, 668), - Trans(8, 44, 20, 668), - Trans(8, 49, 20, 668), - Trans(8, 50, 20, 668), - Trans(8, 51, 20, 668), - Trans(8, 61, 20, 668), - Trans(8, 62, 20, 668), - Trans(8, 65, 20, 668), - Trans(8, 66, 20, 668), - Trans(8, 67, 20, 668), - Trans(8, 71, 20, 668), - Trans(8, 72, 20, 668), - Trans(8, 74, 20, 668), - Trans(8, 78, 20, 668), - Trans(8, 81, 20, 668), - Trans(8, 82, 20, 668), - Trans(8, 85, 20, 668), - Trans(8, 105, 20, 668), - Trans(8, 108, 20, 668), - Trans(8, 111, 20, 668), - Trans(8, 112, 20, 668), - Trans(8, 113, 20, 668), - Trans(9, 5, 20, 668), - Trans(9, 115, 20, 668), - Trans(10, 5, 20, 668), - Trans(10, 37, 20, 668), - Trans(10, 40, 20, 668), - Trans(10, 44, 20, 668), - Trans(10, 115, 20, 668), - Trans(11, 5, 20, 668), - Trans(11, 41, 20, 668), - Trans(12, 5, 20, 668), - Trans(12, 31, 20, 668), - Trans(12, 37, 20, 668), - Trans(12, 40, 20, 668), - Trans(12, 44, 20, 668), - Trans(12, 49, 20, 668), - Trans(12, 50, 20, 668), - Trans(12, 51, 20, 668), - Trans(12, 61, 20, 668), - Trans(12, 62, 20, 668), - Trans(12, 65, 20, 668), - Trans(12, 66, 20, 668), - Trans(12, 67, 20, 668), - Trans(12, 71, 20, 668), - Trans(12, 72, 20, 668), - Trans(12, 74, 20, 668), - Trans(12, 78, 20, 668), - Trans(12, 81, 20, 668), - Trans(12, 82, 20, 668), - Trans(12, 85, 20, 668), - Trans(12, 105, 20, 668), - Trans(12, 108, 20, 668), - Trans(12, 111, 20, 668), - Trans(12, 112, 20, 668), - Trans(12, 113, 20, 668), - Trans(13, 0, 20, 668), - Trans(13, 5, 20, 668), - Trans(13, 31, 20, 668), - Trans(13, 32, 20, 668), - Trans(13, 37, 20, 668), - Trans(13, 40, 20, 668), - Trans(13, 44, 20, 668), - Trans(13, 49, 20, 668), - Trans(13, 50, 20, 668), - Trans(13, 51, 20, 668), - Trans(13, 59, 20, 668), - Trans(13, 60, 20, 668), - Trans(13, 61, 20, 668), - Trans(13, 62, 20, 668), - Trans(13, 65, 20, 668), - Trans(13, 66, 20, 668), - Trans(13, 67, 20, 668), - Trans(13, 71, 20, 668), - Trans(13, 72, 20, 668), - Trans(13, 73, 20, 668), - Trans(13, 74, 20, 668), - Trans(13, 78, 20, 668), - Trans(13, 79, 20, 668), - Trans(13, 81, 20, 668), - Trans(13, 82, 20, 668), - Trans(13, 85, 20, 668), - Trans(13, 86, 20, 668), - Trans(13, 90, 20, 668), - Trans(13, 92, 20, 668), - Trans(13, 105, 20, 668), - Trans(13, 108, 20, 668), - Trans(13, 111, 20, 668), - Trans(13, 112, 20, 668), - Trans(13, 113, 20, 668), - Trans(14, 5, 20, 668), - Trans(14, 40, 20, 668), - Trans(15, 5, 20, 668), - Trans(15, 40, 20, 668), - Trans(15, 42, 20, 668), - Trans(16, 5, 20, 668), - Trans(16, 48, 20, 668), - Trans(16, 114, 20, 668), - Trans(16, 115, 20, 668), - Trans(17, 5, 20, 668), - Trans(17, 6, 20, 668), - Trans(17, 7, 20, 668), - Trans(17, 8, 20, 668), - Trans(17, 9, 20, 668), - Trans(17, 10, 20, 668), - Trans(17, 11, 20, 668), - Trans(17, 18, 20, 668), - Trans(17, 24, 20, 668), - Trans(17, 25, 20, 668), - Trans(17, 26, 20, 668), - Trans(17, 27, 20, 668), - Trans(17, 39, 20, 668), - Trans(17, 40, 20, 668), - Trans(17, 42, 20, 668), - Trans(17, 54, 20, 668), - Trans(17, 71, 20, 668), - Trans(17, 77, 20, 668), - Trans(17, 84, 20, 668), - Trans(17, 87, 20, 668), - Trans(17, 89, 20, 668), - Trans(17, 106, 20, 668), - Trans(17, 114, 20, 668), - Trans(17, 115, 20, 668), - Trans(18, 5, 20, 668), - Trans(18, 114, 20, 668), - Trans(18, 115, 20, 668), - Trans(19, 5, 20, 668), - Trans(19, 42, 20, 668), - Trans(21, 5, 20, 668), - Trans(21, 31, 20, 668), - Trans(21, 32, 20, 668), - Trans(21, 37, 20, 668), - Trans(21, 40, 20, 668), - Trans(21, 44, 20, 668), - Trans(21, 49, 20, 668), - Trans(21, 50, 20, 668), - Trans(21, 51, 20, 668), - Trans(21, 61, 20, 668), - Trans(21, 62, 20, 668), - Trans(21, 65, 20, 668), - Trans(21, 66, 20, 668), - Trans(21, 67, 20, 668), - Trans(21, 71, 20, 668), - Trans(21, 72, 20, 668), - Trans(21, 74, 20, 668), - Trans(21, 78, 20, 668), - Trans(21, 81, 20, 668), - Trans(21, 82, 20, 668), - Trans(21, 85, 20, 668), - Trans(21, 105, 20, 668), - Trans(21, 108, 20, 668), - Trans(21, 111, 20, 668), - Trans(21, 112, 20, 668), - Trans(21, 113, 20, 668), + Trans(7, 114, 19, -1), + Trans(7, 115, 9, -1), + Trans(8, 31, 20, 673), + Trans(8, 32, 20, 673), + Trans(8, 37, 20, 673), + Trans(8, 40, 20, 673), + Trans(8, 44, 20, 673), + Trans(8, 49, 20, 673), + Trans(8, 50, 20, 673), + Trans(8, 51, 20, 673), + Trans(8, 62, 20, 673), + Trans(8, 63, 20, 673), + Trans(8, 66, 20, 673), + Trans(8, 67, 20, 673), + Trans(8, 68, 20, 673), + Trans(8, 72, 20, 673), + Trans(8, 73, 20, 673), + Trans(8, 75, 20, 673), + Trans(8, 79, 20, 673), + Trans(8, 82, 20, 673), + Trans(8, 83, 20, 673), + Trans(8, 86, 20, 673), + Trans(8, 107, 20, 673), + Trans(8, 110, 20, 673), + Trans(8, 113, 20, 673), + Trans(8, 114, 20, 673), + Trans(8, 115, 20, 673), + Trans(9, 5, 20, 673), + Trans(9, 117, 20, 673), + Trans(10, 5, 20, 673), + Trans(10, 37, 20, 673), + Trans(10, 40, 20, 673), + Trans(10, 44, 20, 673), + Trans(10, 117, 20, 673), + Trans(11, 5, 20, 673), + Trans(11, 41, 20, 673), + Trans(12, 5, 20, 673), + Trans(12, 31, 20, 673), + Trans(12, 37, 20, 673), + Trans(12, 40, 20, 673), + Trans(12, 44, 20, 673), + Trans(12, 49, 20, 673), + Trans(12, 50, 20, 673), + Trans(12, 51, 20, 673), + Trans(12, 62, 20, 673), + Trans(12, 63, 20, 673), + Trans(12, 66, 20, 673), + Trans(12, 67, 20, 673), + Trans(12, 68, 20, 673), + Trans(12, 72, 20, 673), + Trans(12, 73, 20, 673), + Trans(12, 75, 20, 673), + Trans(12, 79, 20, 673), + Trans(12, 82, 20, 673), + Trans(12, 83, 20, 673), + Trans(12, 86, 20, 673), + Trans(12, 107, 20, 673), + Trans(12, 110, 20, 673), + Trans(12, 113, 20, 673), + Trans(12, 114, 20, 673), + Trans(12, 115, 20, 673), + Trans(13, 0, 20, 673), + Trans(13, 5, 20, 673), + Trans(13, 31, 20, 673), + Trans(13, 32, 20, 673), + Trans(13, 37, 20, 673), + Trans(13, 40, 20, 673), + Trans(13, 44, 20, 673), + Trans(13, 49, 20, 673), + Trans(13, 50, 20, 673), + Trans(13, 51, 20, 673), + Trans(13, 60, 20, 673), + Trans(13, 61, 20, 673), + Trans(13, 62, 20, 673), + Trans(13, 63, 20, 673), + Trans(13, 66, 20, 673), + Trans(13, 67, 20, 673), + Trans(13, 68, 20, 673), + Trans(13, 72, 20, 673), + Trans(13, 73, 20, 673), + Trans(13, 74, 20, 673), + Trans(13, 75, 20, 673), + Trans(13, 79, 20, 673), + Trans(13, 80, 20, 673), + Trans(13, 82, 20, 673), + Trans(13, 83, 20, 673), + Trans(13, 86, 20, 673), + Trans(13, 87, 20, 673), + Trans(13, 91, 20, 673), + Trans(13, 93, 20, 673), + Trans(13, 94, 20, 673), + Trans(13, 107, 20, 673), + Trans(13, 110, 20, 673), + Trans(13, 113, 20, 673), + Trans(13, 114, 20, 673), + Trans(13, 115, 20, 673), + Trans(14, 5, 20, 673), + Trans(14, 40, 20, 673), + Trans(15, 5, 20, 673), + Trans(15, 40, 20, 673), + Trans(15, 42, 20, 673), + Trans(16, 5, 20, 673), + Trans(16, 48, 20, 673), + Trans(16, 116, 20, 673), + Trans(16, 117, 20, 673), + Trans(17, 5, 20, 673), + Trans(17, 6, 20, 673), + Trans(17, 7, 20, 673), + Trans(17, 8, 20, 673), + Trans(17, 9, 20, 673), + Trans(17, 10, 20, 673), + Trans(17, 11, 20, 673), + Trans(17, 18, 20, 673), + Trans(17, 24, 20, 673), + Trans(17, 25, 20, 673), + Trans(17, 26, 20, 673), + Trans(17, 27, 20, 673), + Trans(17, 39, 20, 673), + Trans(17, 40, 20, 673), + Trans(17, 42, 20, 673), + Trans(17, 54, 20, 673), + Trans(17, 72, 20, 673), + Trans(17, 78, 20, 673), + Trans(17, 85, 20, 673), + Trans(17, 88, 20, 673), + Trans(17, 90, 20, 673), + Trans(17, 108, 20, 673), + Trans(17, 116, 20, 673), + Trans(17, 117, 20, 673), + Trans(18, 5, 20, 673), + Trans(18, 116, 20, 673), + Trans(18, 117, 20, 673), + Trans(19, 5, 20, 673), + Trans(19, 42, 20, 673), + Trans(21, 5, 20, 673), + Trans(21, 31, 20, 673), + Trans(21, 32, 20, 673), + Trans(21, 37, 20, 673), + Trans(21, 40, 20, 673), + Trans(21, 44, 20, 673), + Trans(21, 49, 20, 673), + Trans(21, 50, 20, 673), + Trans(21, 51, 20, 673), + Trans(21, 62, 20, 673), + Trans(21, 63, 20, 673), + Trans(21, 66, 20, 673), + Trans(21, 67, 20, 673), + Trans(21, 68, 20, 673), + Trans(21, 72, 20, 673), + Trans(21, 73, 20, 673), + Trans(21, 75, 20, 673), + Trans(21, 79, 20, 673), + Trans(21, 82, 20, 673), + Trans(21, 83, 20, 673), + Trans(21, 86, 20, 673), + Trans(21, 107, 20, 673), + Trans(21, 110, 20, 673), + Trans(21, 113, 20, 673), + Trans(21, 114, 20, 673), + Trans(21, 115, 20, 673), ], k: 3, }, - /* 155 - "EnumListOpt" */ + /* 158 - "EnumListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 669), Trans(0, 44, 2, 670)], + transitions: &[Trans(0, 32, 1, 674), Trans(0, 44, 2, 675)], k: 1, }, - /* 156 - "EnumTerm" */ + /* 159 - "EnumTerm" */ LookaheadDFA { - prod0: 56, + prod0: 57, transitions: &[], k: 0, }, - /* 157 - "EnumToken" */ + /* 160 - "EnumToken" */ LookaheadDFA { - prod0: 171, + prod0: 174, transitions: &[], k: 0, }, - /* 158 - "Equ" */ + /* 161 - "Equ" */ LookaheadDFA { - prod0: 254, + prod0: 258, transitions: &[], k: 0, }, - /* 159 - "EquTerm" */ + /* 162 - "EquTerm" */ LookaheadDFA { prod0: 31, transitions: &[], k: 0, }, - /* 160 - "EquToken" */ + /* 163 - "EquToken" */ LookaheadDFA { - prod0: 143, + prod0: 145, transitions: &[], k: 0, }, - /* 161 - "Exponent" */ + /* 164 - "Exponent" */ LookaheadDFA { - prod0: 228, + prod0: 232, transitions: &[], k: 0, }, - /* 162 - "ExponentTerm" */ + /* 165 - "ExponentTerm" */ LookaheadDFA { prod0: 2, transitions: &[], k: 0, }, - /* 163 - "ExponentToken" */ + /* 166 - "ExponentToken" */ LookaheadDFA { - prod0: 117, + prod0: 119, transitions: &[], k: 0, }, - /* 164 - "Export" */ + /* 167 - "Export" */ LookaheadDFA { - prod0: 284, + prod0: 289, transitions: &[], k: 0, }, - /* 165 - "ExportDeclaration" */ + /* 168 - "ExportDeclaration" */ LookaheadDFA { - prod0: 820, + prod0: 828, transitions: &[], k: 0, }, - /* 166 - "ExportDeclarationGroup" */ + /* 169 - "ExportDeclarationGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 48, 1, 821), - Trans(0, 114, 2, 822), - Trans(0, 115, 2, 822), + Trans(0, 48, 1, 829), + Trans(0, 116, 2, 830), + Trans(0, 117, 2, 830), ], k: 1, }, - /* 167 - "ExportDeclarationOpt" */ + /* 170 - "ExportDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 823), Trans(0, 47, 2, 824)], + transitions: &[Trans(0, 30, 1, 831), Trans(0, 47, 2, 832)], k: 1, }, - /* 168 - "ExportTerm" */ + /* 171 - "ExportTerm" */ LookaheadDFA { - prod0: 57, - transitions: &[], - k: 0, - }, - /* 169 - "ExportToken" */ - LookaheadDFA { - prod0: 172, - transitions: &[], - k: 0, - }, - /* 170 - "Expression" */ - LookaheadDFA { - prod0: 367, + prod0: 58, transitions: &[], k: 0, }, - /* 171 - "Expression01" */ + /* 172 - "ExportToken" */ LookaheadDFA { - prod0: 370, + prod0: 175, transitions: &[], k: 0, }, - /* 172 - "Expression01List" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 12, 2, 372), - Trans(0, 14, 2, 372), - Trans(0, 22, 1, 371), - Trans(0, 23, 2, 372), - Trans(0, 31, 2, 372), - Trans(0, 32, 2, 372), - Trans(0, 33, 2, 372), - Trans(0, 34, 2, 372), - Trans(0, 40, 2, 372), - Trans(0, 43, 2, 372), - Trans(0, 44, 2, 372), - Trans(0, 45, 2, 372), - Trans(0, 46, 2, 372), - Trans(0, 47, 2, 372), - Trans(0, 94, 2, 372), - Trans(0, 103, 2, 372), - ], - k: 1, - }, - /* 173 - "Expression02" */ + /* 173 - "Expression" */ LookaheadDFA { prod0: 373, transitions: &[], k: 0, }, - /* 174 - "Expression02List" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 12, 2, 375), - Trans(0, 14, 2, 375), - Trans(0, 22, 2, 375), - Trans(0, 23, 2, 375), - Trans(0, 26, 1, 374), - Trans(0, 31, 2, 375), - Trans(0, 32, 2, 375), - Trans(0, 33, 2, 375), - Trans(0, 34, 2, 375), - Trans(0, 40, 2, 375), - Trans(0, 43, 2, 375), - Trans(0, 44, 2, 375), - Trans(0, 45, 2, 375), - Trans(0, 46, 2, 375), - Trans(0, 47, 2, 375), - Trans(0, 94, 2, 375), - Trans(0, 103, 2, 375), - ], - k: 1, - }, - /* 175 - "Expression03" */ + /* 174 - "Expression01" */ LookaheadDFA { prod0: 376, transitions: &[], k: 0, }, - /* 176 - "Expression03List" */ + /* 175 - "Expression01List" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 12, 2, 378), Trans(0, 14, 2, 378), - Trans(0, 22, 2, 378), + Trans(0, 22, 1, 377), Trans(0, 23, 2, 378), - Trans(0, 25, 1, 377), - Trans(0, 26, 2, 378), Trans(0, 31, 2, 378), Trans(0, 32, 2, 378), Trans(0, 33, 2, 378), @@ -4744,18 +4738,18 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 45, 2, 378), Trans(0, 46, 2, 378), Trans(0, 47, 2, 378), - Trans(0, 94, 2, 378), - Trans(0, 103, 2, 378), + Trans(0, 96, 2, 378), + Trans(0, 105, 2, 378), ], k: 1, }, - /* 177 - "Expression04" */ + /* 176 - "Expression02" */ LookaheadDFA { prod0: 379, transitions: &[], k: 0, }, - /* 178 - "Expression04List" */ + /* 177 - "Expression02List" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -4763,9 +4757,7 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 14, 2, 381), Trans(0, 22, 2, 381), Trans(0, 23, 2, 381), - Trans(0, 24, 1, 380), - Trans(0, 25, 2, 381), - Trans(0, 26, 2, 381), + Trans(0, 26, 1, 380), Trans(0, 31, 2, 381), Trans(0, 32, 2, 381), Trans(0, 33, 2, 381), @@ -4776,28 +4768,26 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 45, 2, 381), Trans(0, 46, 2, 381), Trans(0, 47, 2, 381), - Trans(0, 94, 2, 381), - Trans(0, 103, 2, 381), + Trans(0, 96, 2, 381), + Trans(0, 105, 2, 381), ], k: 1, }, - /* 179 - "Expression05" */ + /* 178 - "Expression03" */ LookaheadDFA { prod0: 382, transitions: &[], k: 0, }, - /* 180 - "Expression05List" */ + /* 179 - "Expression03List" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 12, 2, 384), Trans(0, 14, 2, 384), - Trans(0, 21, 1, 383), Trans(0, 22, 2, 384), Trans(0, 23, 2, 384), - Trans(0, 24, 2, 384), - Trans(0, 25, 2, 384), + Trans(0, 25, 1, 383), Trans(0, 26, 2, 384), Trans(0, 31, 2, 384), Trans(0, 32, 2, 384), @@ -4809,28 +4799,26 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 45, 2, 384), Trans(0, 46, 2, 384), Trans(0, 47, 2, 384), - Trans(0, 94, 2, 384), - Trans(0, 103, 2, 384), + Trans(0, 96, 2, 384), + Trans(0, 105, 2, 384), ], k: 1, }, - /* 181 - "Expression06" */ + /* 180 - "Expression04" */ LookaheadDFA { prod0: 385, transitions: &[], k: 0, }, - /* 182 - "Expression06List" */ + /* 181 - "Expression04List" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 12, 2, 387), Trans(0, 14, 2, 387), - Trans(0, 20, 1, 386), - Trans(0, 21, 2, 387), Trans(0, 22, 2, 387), Trans(0, 23, 2, 387), - Trans(0, 24, 2, 387), + Trans(0, 24, 1, 386), Trans(0, 25, 2, 387), Trans(0, 26, 2, 387), Trans(0, 31, 2, 387), @@ -4843,26 +4831,24 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 45, 2, 387), Trans(0, 46, 2, 387), Trans(0, 47, 2, 387), - Trans(0, 94, 2, 387), - Trans(0, 103, 2, 387), + Trans(0, 96, 2, 387), + Trans(0, 105, 2, 387), ], k: 1, }, - /* 183 - "Expression07" */ + /* 182 - "Expression05" */ LookaheadDFA { prod0: 388, transitions: &[], k: 0, }, - /* 184 - "Expression07List" */ + /* 183 - "Expression05List" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 12, 2, 390), Trans(0, 14, 2, 390), - Trans(0, 19, 1, 389), - Trans(0, 20, 2, 390), - Trans(0, 21, 2, 390), + Trans(0, 21, 1, 389), Trans(0, 22, 2, 390), Trans(0, 23, 2, 390), Trans(0, 24, 2, 390), @@ -4878,26 +4864,24 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 45, 2, 390), Trans(0, 46, 2, 390), Trans(0, 47, 2, 390), - Trans(0, 94, 2, 390), - Trans(0, 103, 2, 390), + Trans(0, 96, 2, 390), + Trans(0, 105, 2, 390), ], k: 1, }, - /* 185 - "Expression08" */ + /* 184 - "Expression06" */ LookaheadDFA { prod0: 391, transitions: &[], k: 0, }, - /* 186 - "Expression08List" */ + /* 185 - "Expression06List" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 12, 2, 393), Trans(0, 14, 2, 393), - Trans(0, 18, 1, 392), - Trans(0, 19, 2, 393), - Trans(0, 20, 2, 393), + Trans(0, 20, 1, 392), Trans(0, 21, 2, 393), Trans(0, 22, 2, 393), Trans(0, 23, 2, 393), @@ -4914,108 +4898,95 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 45, 2, 393), Trans(0, 46, 2, 393), Trans(0, 47, 2, 393), - Trans(0, 94, 2, 393), - Trans(0, 103, 2, 393), + Trans(0, 96, 2, 393), + Trans(0, 105, 2, 393), ], k: 1, }, - /* 187 - "Expression09" */ + /* 186 - "Expression07" */ LookaheadDFA { prod0: 394, transitions: &[], k: 0, }, - /* 188 - "Expression09List" */ + /* 187 - "Expression07List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 398), - Trans(0, 14, 2, 398), - Trans(0, 17, 1, 395), - Trans(0, 18, 2, 398), - Trans(0, 19, 2, 398), - Trans(0, 20, 2, 398), - Trans(0, 21, 2, 398), - Trans(0, 22, 2, 398), - Trans(0, 23, 2, 398), - Trans(0, 24, 2, 398), - Trans(0, 25, 2, 398), - Trans(0, 26, 2, 398), - Trans(0, 31, 2, 398), - Trans(0, 32, 2, 398), - Trans(0, 33, 2, 398), - Trans(0, 34, 2, 398), - Trans(0, 40, 2, 398), - Trans(0, 43, 2, 398), - Trans(0, 44, 2, 398), - Trans(0, 45, 2, 398), - Trans(0, 46, 2, 398), - Trans(0, 47, 2, 398), - Trans(0, 48, 1, 395), - Trans(0, 94, 2, 398), - Trans(0, 103, 2, 398), + Trans(0, 12, 2, 396), + Trans(0, 14, 2, 396), + Trans(0, 19, 1, 395), + Trans(0, 20, 2, 396), + Trans(0, 21, 2, 396), + Trans(0, 22, 2, 396), + Trans(0, 23, 2, 396), + Trans(0, 24, 2, 396), + Trans(0, 25, 2, 396), + Trans(0, 26, 2, 396), + Trans(0, 31, 2, 396), + Trans(0, 32, 2, 396), + Trans(0, 33, 2, 396), + Trans(0, 34, 2, 396), + Trans(0, 40, 2, 396), + Trans(0, 43, 2, 396), + Trans(0, 44, 2, 396), + Trans(0, 45, 2, 396), + Trans(0, 46, 2, 396), + Trans(0, 47, 2, 396), + Trans(0, 96, 2, 396), + Trans(0, 105, 2, 396), ], k: 1, }, - /* 189 - "Expression09ListGroup" */ - LookaheadDFA { - prod0: -1, - transitions: &[Trans(0, 17, 1, 396), Trans(0, 48, 2, 397)], - k: 1, - }, - /* 190 - "Expression10" */ + /* 188 - "Expression08" */ LookaheadDFA { - prod0: 399, + prod0: 397, transitions: &[], k: 0, }, - /* 191 - "Expression10List" */ + /* 189 - "Expression08List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 401), - Trans(0, 14, 2, 401), - Trans(0, 16, 1, 400), - Trans(0, 17, 2, 401), - Trans(0, 18, 2, 401), - Trans(0, 19, 2, 401), - Trans(0, 20, 2, 401), - Trans(0, 21, 2, 401), - Trans(0, 22, 2, 401), - Trans(0, 23, 2, 401), - Trans(0, 24, 2, 401), - Trans(0, 25, 2, 401), - Trans(0, 26, 2, 401), - Trans(0, 31, 2, 401), - Trans(0, 32, 2, 401), - Trans(0, 33, 2, 401), - Trans(0, 34, 2, 401), - Trans(0, 40, 2, 401), - Trans(0, 43, 2, 401), - Trans(0, 44, 2, 401), - Trans(0, 45, 2, 401), - Trans(0, 46, 2, 401), - Trans(0, 47, 2, 401), - Trans(0, 48, 2, 401), - Trans(0, 94, 2, 401), - Trans(0, 103, 2, 401), + Trans(0, 12, 2, 399), + Trans(0, 14, 2, 399), + Trans(0, 18, 1, 398), + Trans(0, 19, 2, 399), + Trans(0, 20, 2, 399), + Trans(0, 21, 2, 399), + Trans(0, 22, 2, 399), + Trans(0, 23, 2, 399), + Trans(0, 24, 2, 399), + Trans(0, 25, 2, 399), + Trans(0, 26, 2, 399), + Trans(0, 31, 2, 399), + Trans(0, 32, 2, 399), + Trans(0, 33, 2, 399), + Trans(0, 34, 2, 399), + Trans(0, 40, 2, 399), + Trans(0, 43, 2, 399), + Trans(0, 44, 2, 399), + Trans(0, 45, 2, 399), + Trans(0, 46, 2, 399), + Trans(0, 47, 2, 399), + Trans(0, 96, 2, 399), + Trans(0, 105, 2, 399), ], k: 1, }, - /* 192 - "Expression11" */ + /* 190 - "Expression09" */ LookaheadDFA { - prod0: 402, + prod0: 400, transitions: &[], k: 0, }, - /* 193 - "Expression11Opt" */ + /* 191 - "Expression09List" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 12, 2, 404), Trans(0, 14, 2, 404), - Trans(0, 16, 2, 404), - Trans(0, 17, 2, 404), + Trans(0, 17, 1, 401), Trans(0, 18, 2, 404), Trans(0, 19, 2, 404), Trans(0, 20, 2, 404), @@ -5035,787 +5006,882 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 45, 2, 404), Trans(0, 46, 2, 404), Trans(0, 47, 2, 404), - Trans(0, 48, 2, 404), - Trans(0, 52, 1, 403), - Trans(0, 94, 2, 404), - Trans(0, 103, 2, 404), + Trans(0, 48, 1, 401), + Trans(0, 96, 2, 404), + Trans(0, 105, 2, 404), ], k: 1, }, - /* 194 - "Expression12" */ + /* 192 - "Expression09ListGroup" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 17, 1, 402), Trans(0, 48, 2, 403)], + k: 1, + }, + /* 193 - "Expression10" */ LookaheadDFA { prod0: 405, transitions: &[], k: 0, }, - /* 195 - "Expression12List" */ + /* 194 - "Expression10List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 2, 412), - Trans(0, 7, 2, 412), - Trans(0, 8, 2, 412), - Trans(0, 9, 2, 412), - Trans(0, 10, 2, 412), - Trans(0, 11, 2, 412), - Trans(0, 18, 1, 406), - Trans(0, 24, 1, 406), - Trans(0, 25, 1, 406), - Trans(0, 26, 1, 406), - Trans(0, 27, 1, 406), - Trans(0, 39, 2, 412), - Trans(0, 40, 2, 412), - Trans(0, 42, 2, 412), - Trans(0, 54, 2, 412), - Trans(0, 71, 2, 412), - Trans(0, 77, 2, 412), - Trans(0, 84, 2, 412), - Trans(0, 87, 2, 412), - Trans(0, 89, 2, 412), - Trans(0, 106, 2, 412), - Trans(0, 114, 2, 412), - Trans(0, 115, 2, 412), + Trans(0, 12, 2, 407), + Trans(0, 14, 2, 407), + Trans(0, 16, 1, 406), + Trans(0, 17, 2, 407), + Trans(0, 18, 2, 407), + Trans(0, 19, 2, 407), + Trans(0, 20, 2, 407), + Trans(0, 21, 2, 407), + Trans(0, 22, 2, 407), + Trans(0, 23, 2, 407), + Trans(0, 24, 2, 407), + Trans(0, 25, 2, 407), + Trans(0, 26, 2, 407), + Trans(0, 31, 2, 407), + Trans(0, 32, 2, 407), + Trans(0, 33, 2, 407), + Trans(0, 34, 2, 407), + Trans(0, 40, 2, 407), + Trans(0, 43, 2, 407), + Trans(0, 44, 2, 407), + Trans(0, 45, 2, 407), + Trans(0, 46, 2, 407), + Trans(0, 47, 2, 407), + Trans(0, 48, 2, 407), + Trans(0, 96, 2, 407), + Trans(0, 105, 2, 407), ], k: 1, }, - /* 196 - "Expression12ListGroup" */ + /* 195 - "Expression11" */ + LookaheadDFA { + prod0: 408, + transitions: &[], + k: 0, + }, + /* 196 - "Expression11Opt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 18, 2, 408), - Trans(0, 24, 3, 409), - Trans(0, 25, 5, 411), - Trans(0, 26, 4, 410), - Trans(0, 27, 1, 407), + Trans(0, 12, 2, 410), + Trans(0, 14, 2, 410), + Trans(0, 16, 2, 410), + Trans(0, 17, 2, 410), + Trans(0, 18, 2, 410), + Trans(0, 19, 2, 410), + Trans(0, 20, 2, 410), + Trans(0, 21, 2, 410), + Trans(0, 22, 2, 410), + Trans(0, 23, 2, 410), + Trans(0, 24, 2, 410), + Trans(0, 25, 2, 410), + Trans(0, 26, 2, 410), + Trans(0, 31, 2, 410), + Trans(0, 32, 2, 410), + Trans(0, 33, 2, 410), + Trans(0, 34, 2, 410), + Trans(0, 40, 2, 410), + Trans(0, 43, 2, 410), + Trans(0, 44, 2, 410), + Trans(0, 45, 2, 410), + Trans(0, 46, 2, 410), + Trans(0, 47, 2, 410), + Trans(0, 48, 2, 410), + Trans(0, 52, 1, 409), + Trans(0, 96, 2, 410), + Trans(0, 105, 2, 410), ], k: 1, }, - /* 197 - "ExpressionIdentifier" */ + /* 197 - "Expression12" */ LookaheadDFA { - prod0: 360, + prod0: 411, transitions: &[], k: 0, }, - /* 198 - "ExpressionIdentifierList" */ + /* 198 - "Expression12List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 366), - Trans(0, 14, 2, 366), - Trans(0, 15, 2, 366), - Trans(0, 16, 2, 366), - Trans(0, 17, 2, 366), - Trans(0, 18, 2, 366), - Trans(0, 19, 2, 366), - Trans(0, 20, 2, 366), - Trans(0, 21, 2, 366), - Trans(0, 22, 2, 366), - Trans(0, 23, 2, 366), - Trans(0, 24, 2, 366), - Trans(0, 25, 2, 366), - Trans(0, 26, 2, 366), - Trans(0, 31, 2, 366), - Trans(0, 32, 2, 366), - Trans(0, 33, 2, 366), - Trans(0, 34, 2, 366), - Trans(0, 35, 2, 366), - Trans(0, 36, 2, 366), - Trans(0, 40, 2, 366), - Trans(0, 41, 1, 365), - 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, 47, 2, 366), - Trans(0, 48, 2, 366), - Trans(0, 52, 2, 366), - Trans(0, 94, 2, 366), - Trans(0, 103, 2, 366), + Trans(0, 6, 2, 418), + Trans(0, 7, 2, 418), + Trans(0, 8, 2, 418), + Trans(0, 9, 2, 418), + Trans(0, 10, 2, 418), + Trans(0, 11, 2, 418), + Trans(0, 18, 1, 412), + Trans(0, 24, 1, 412), + Trans(0, 25, 1, 412), + Trans(0, 26, 1, 412), + Trans(0, 27, 1, 412), + Trans(0, 39, 2, 418), + Trans(0, 40, 2, 418), + Trans(0, 42, 2, 418), + Trans(0, 54, 2, 418), + Trans(0, 72, 2, 418), + Trans(0, 78, 2, 418), + Trans(0, 85, 2, 418), + Trans(0, 88, 2, 418), + Trans(0, 90, 2, 418), + Trans(0, 108, 2, 418), + Trans(0, 116, 2, 418), + Trans(0, 117, 2, 418), ], k: 1, }, - /* 199 - "ExpressionIdentifierList0" */ + /* 199 - "Expression12ListGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 364), - Trans(0, 14, 2, 364), - Trans(0, 15, 2, 364), - Trans(0, 16, 2, 364), - Trans(0, 17, 2, 364), - Trans(0, 18, 2, 364), - Trans(0, 19, 2, 364), - Trans(0, 20, 2, 364), - Trans(0, 21, 2, 364), - Trans(0, 22, 2, 364), - Trans(0, 23, 2, 364), - Trans(0, 24, 2, 364), - Trans(0, 25, 2, 364), - Trans(0, 26, 2, 364), - Trans(0, 31, 2, 364), - Trans(0, 32, 2, 364), - Trans(0, 33, 2, 364), - Trans(0, 34, 2, 364), - Trans(0, 35, 1, 361), - Trans(0, 36, 2, 364), - Trans(0, 40, 2, 364), - Trans(0, 42, 2, 364), - Trans(0, 43, 2, 364), - Trans(0, 44, 2, 364), - Trans(0, 45, 2, 364), - Trans(0, 46, 2, 364), - Trans(0, 47, 2, 364), - Trans(0, 48, 2, 364), - Trans(0, 52, 2, 364), - Trans(0, 94, 2, 364), - Trans(0, 103, 2, 364), + Trans(0, 18, 2, 414), + Trans(0, 24, 3, 415), + Trans(0, 25, 5, 417), + Trans(0, 26, 4, 416), + Trans(0, 27, 1, 413), ], k: 1, }, - /* 200 - "ExpressionIdentifierList0List" */ + /* 200 - "ExpressionIdentifier" */ + LookaheadDFA { + prod0: 366, + transitions: &[], + k: 0, + }, + /* 201 - "ExpressionIdentifierList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 363), - Trans(0, 14, 2, 363), - Trans(0, 15, 2, 363), - Trans(0, 16, 2, 363), - Trans(0, 17, 2, 363), - Trans(0, 18, 2, 363), - Trans(0, 19, 2, 363), - Trans(0, 20, 2, 363), - Trans(0, 21, 2, 363), - Trans(0, 22, 2, 363), - Trans(0, 23, 2, 363), - Trans(0, 24, 2, 363), - Trans(0, 25, 2, 363), - Trans(0, 26, 2, 363), - Trans(0, 31, 2, 363), - Trans(0, 32, 2, 363), - Trans(0, 33, 2, 363), - Trans(0, 34, 2, 363), - Trans(0, 35, 2, 363), - Trans(0, 36, 2, 363), - Trans(0, 40, 2, 363), - Trans(0, 41, 1, 362), - 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, 47, 2, 363), - Trans(0, 48, 2, 363), - Trans(0, 52, 2, 363), - Trans(0, 94, 2, 363), - Trans(0, 103, 2, 363), + Trans(0, 12, 2, 372), + Trans(0, 14, 2, 372), + Trans(0, 15, 2, 372), + Trans(0, 16, 2, 372), + Trans(0, 17, 2, 372), + Trans(0, 18, 2, 372), + Trans(0, 19, 2, 372), + Trans(0, 20, 2, 372), + Trans(0, 21, 2, 372), + Trans(0, 22, 2, 372), + Trans(0, 23, 2, 372), + Trans(0, 24, 2, 372), + Trans(0, 25, 2, 372), + Trans(0, 26, 2, 372), + Trans(0, 31, 2, 372), + Trans(0, 32, 2, 372), + Trans(0, 33, 2, 372), + Trans(0, 34, 2, 372), + Trans(0, 35, 2, 372), + Trans(0, 36, 2, 372), + Trans(0, 40, 2, 372), + Trans(0, 41, 1, 371), + 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, 47, 2, 372), + Trans(0, 48, 2, 372), + Trans(0, 52, 2, 372), + Trans(0, 96, 2, 372), + Trans(0, 105, 2, 372), + ], + k: 1, + }, + /* 202 - "ExpressionIdentifierList0" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 12, 2, 370), + Trans(0, 14, 2, 370), + Trans(0, 15, 2, 370), + Trans(0, 16, 2, 370), + Trans(0, 17, 2, 370), + Trans(0, 18, 2, 370), + Trans(0, 19, 2, 370), + Trans(0, 20, 2, 370), + Trans(0, 21, 2, 370), + Trans(0, 22, 2, 370), + Trans(0, 23, 2, 370), + Trans(0, 24, 2, 370), + Trans(0, 25, 2, 370), + Trans(0, 26, 2, 370), + Trans(0, 31, 2, 370), + Trans(0, 32, 2, 370), + Trans(0, 33, 2, 370), + Trans(0, 34, 2, 370), + Trans(0, 35, 1, 367), + Trans(0, 36, 2, 370), + Trans(0, 40, 2, 370), + Trans(0, 42, 2, 370), + Trans(0, 43, 2, 370), + Trans(0, 44, 2, 370), + Trans(0, 45, 2, 370), + Trans(0, 46, 2, 370), + Trans(0, 47, 2, 370), + Trans(0, 48, 2, 370), + Trans(0, 52, 2, 370), + Trans(0, 96, 2, 370), + Trans(0, 105, 2, 370), ], k: 1, }, - /* 201 - "ExpressionList" */ + /* 203 - "ExpressionIdentifierList0List" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 12, 2, 369), Trans(0, 14, 2, 369), - Trans(0, 23, 1, 368), + Trans(0, 15, 2, 369), + Trans(0, 16, 2, 369), + Trans(0, 17, 2, 369), + Trans(0, 18, 2, 369), + Trans(0, 19, 2, 369), + Trans(0, 20, 2, 369), + Trans(0, 21, 2, 369), + Trans(0, 22, 2, 369), + Trans(0, 23, 2, 369), + Trans(0, 24, 2, 369), + Trans(0, 25, 2, 369), + Trans(0, 26, 2, 369), Trans(0, 31, 2, 369), Trans(0, 32, 2, 369), Trans(0, 33, 2, 369), Trans(0, 34, 2, 369), + Trans(0, 35, 2, 369), + Trans(0, 36, 2, 369), Trans(0, 40, 2, 369), + Trans(0, 41, 1, 368), + 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, 47, 2, 369), - Trans(0, 94, 2, 369), - Trans(0, 103, 2, 369), + Trans(0, 48, 2, 369), + Trans(0, 52, 2, 369), + Trans(0, 96, 2, 369), + Trans(0, 105, 2, 369), ], k: 1, }, - /* 202 - "F32" */ + /* 204 - "ExpressionList" */ LookaheadDFA { - prod0: 285, + prod0: -1, + transitions: &[ + Trans(0, 12, 2, 375), + Trans(0, 14, 2, 375), + Trans(0, 23, 1, 374), + Trans(0, 31, 2, 375), + Trans(0, 32, 2, 375), + Trans(0, 33, 2, 375), + Trans(0, 34, 2, 375), + Trans(0, 40, 2, 375), + Trans(0, 43, 2, 375), + Trans(0, 44, 2, 375), + Trans(0, 45, 2, 375), + Trans(0, 46, 2, 375), + Trans(0, 47, 2, 375), + Trans(0, 96, 2, 375), + Trans(0, 105, 2, 375), + ], + k: 1, + }, + /* 205 - "F32" */ + LookaheadDFA { + prod0: 290, transitions: &[], k: 0, }, - /* 203 - "F32Term" */ + /* 206 - "F32Term" */ LookaheadDFA { - prod0: 58, + prod0: 59, transitions: &[], k: 0, }, - /* 204 - "F32Token" */ + /* 207 - "F32Token" */ LookaheadDFA { - prod0: 173, + prod0: 176, transitions: &[], k: 0, }, - /* 205 - "F64" */ + /* 208 - "F64" */ LookaheadDFA { - prod0: 286, + prod0: 291, transitions: &[], k: 0, }, - /* 206 - "F64Term" */ + /* 209 - "F64Term" */ LookaheadDFA { - prod0: 59, + prod0: 60, transitions: &[], k: 0, }, - /* 207 - "F64Token" */ + /* 210 - "F64Token" */ LookaheadDFA { - prod0: 174, + prod0: 177, transitions: &[], k: 0, }, - /* 208 - "Factor" */ + /* 211 - "Factor" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 9, 421), - 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, 39, 5, 417), - Trans(0, 40, 4, 416), - Trans(0, 42, 3, 415), - Trans(0, 54, 7, 419), - Trans(0, 71, 6, 418), - Trans(0, 77, 11, 425), - Trans(0, 84, 10, 422), - Trans(0, 87, 10, 422), - Trans(0, 89, 12, 426), - Trans(0, 106, 8, 420), - Trans(0, 114, 2, 414), - Trans(0, 115, 2, 414), + Trans(0, 6, 9, 427), + Trans(0, 7, 1, 419), + Trans(0, 8, 1, 419), + Trans(0, 9, 1, 419), + Trans(0, 10, 1, 419), + Trans(0, 11, 1, 419), + Trans(0, 39, 5, 423), + Trans(0, 40, 4, 422), + Trans(0, 42, 3, 421), + Trans(0, 54, 7, 425), + Trans(0, 72, 6, 424), + Trans(0, 78, 11, 431), + Trans(0, 85, 10, 428), + Trans(0, 88, 10, 428), + Trans(0, 90, 12, 432), + Trans(0, 108, 8, 426), + Trans(0, 116, 2, 420), + Trans(0, 117, 2, 420), ], k: 1, }, - /* 209 - "FactorGroup" */ + /* 212 - "FactorGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 84, 2, 424), Trans(0, 87, 1, 423)], + transitions: &[Trans(0, 85, 2, 430), Trans(0, 88, 1, 429)], k: 1, }, - /* 210 - "FactorOpt" */ + /* 213 - "FactorOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 428), - Trans(0, 14, 2, 428), - Trans(0, 16, 2, 428), - Trans(0, 17, 2, 428), - Trans(0, 18, 2, 428), - Trans(0, 19, 2, 428), - Trans(0, 20, 2, 428), - Trans(0, 21, 2, 428), - Trans(0, 22, 2, 428), - Trans(0, 23, 2, 428), - Trans(0, 24, 2, 428), - Trans(0, 25, 2, 428), - Trans(0, 26, 2, 428), - Trans(0, 31, 2, 428), - Trans(0, 32, 2, 428), - Trans(0, 33, 2, 428), - Trans(0, 34, 2, 428), - Trans(0, 40, 2, 428), - Trans(0, 42, 1, 427), - Trans(0, 43, 2, 428), - Trans(0, 44, 2, 428), - Trans(0, 45, 2, 428), - Trans(0, 46, 2, 428), - Trans(0, 47, 2, 428), - Trans(0, 48, 2, 428), - Trans(0, 52, 2, 428), - Trans(0, 94, 2, 428), - Trans(0, 103, 2, 428), + Trans(0, 12, 2, 434), + Trans(0, 14, 2, 434), + Trans(0, 16, 2, 434), + Trans(0, 17, 2, 434), + Trans(0, 18, 2, 434), + Trans(0, 19, 2, 434), + Trans(0, 20, 2, 434), + Trans(0, 21, 2, 434), + Trans(0, 22, 2, 434), + Trans(0, 23, 2, 434), + Trans(0, 24, 2, 434), + Trans(0, 25, 2, 434), + Trans(0, 26, 2, 434), + Trans(0, 31, 2, 434), + Trans(0, 32, 2, 434), + Trans(0, 33, 2, 434), + Trans(0, 34, 2, 434), + Trans(0, 40, 2, 434), + Trans(0, 42, 1, 433), + Trans(0, 43, 2, 434), + Trans(0, 44, 2, 434), + Trans(0, 45, 2, 434), + Trans(0, 46, 2, 434), + Trans(0, 47, 2, 434), + Trans(0, 48, 2, 434), + Trans(0, 52, 2, 434), + Trans(0, 96, 2, 434), + Trans(0, 105, 2, 434), ], k: 1, }, - /* 211 - "Final" */ + /* 214 - "Final" */ LookaheadDFA { - prod0: 287, + prod0: 292, transitions: &[], k: 0, }, - /* 212 - "FinalDeclaration" */ + /* 215 - "FinalDeclaration" */ LookaheadDFA { - prod0: 698, + prod0: 703, transitions: &[], k: 0, }, - /* 213 - "FinalDeclarationList" */ + /* 216 - "FinalDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 700), - Trans(0, 54, 1, 699), - Trans(0, 66, 1, 699), - Trans(0, 70, 1, 699), - Trans(0, 71, 1, 699), - Trans(0, 81, 1, 699), - Trans(0, 100, 1, 699), - Trans(0, 101, 1, 699), - Trans(0, 106, 1, 699), - Trans(0, 114, 1, 699), - Trans(0, 115, 1, 699), + Trans(0, 44, 2, 705), + Trans(0, 54, 1, 704), + Trans(0, 67, 1, 704), + Trans(0, 71, 1, 704), + Trans(0, 72, 1, 704), + Trans(0, 82, 1, 704), + Trans(0, 102, 1, 704), + Trans(0, 103, 1, 704), + Trans(0, 108, 1, 704), + Trans(0, 116, 1, 704), + Trans(0, 117, 1, 704), ], k: 1, }, - /* 214 - "FinalTerm" */ + /* 217 - "FinalTerm" */ LookaheadDFA { - prod0: 60, + prod0: 61, transitions: &[], k: 0, }, - /* 215 - "FinalToken" */ + /* 218 - "FinalToken" */ LookaheadDFA { - prod0: 175, + prod0: 178, transitions: &[], k: 0, }, - /* 216 - "FixedPoint" */ + /* 219 - "FixedPoint" */ LookaheadDFA { - prod0: 229, + prod0: 233, transitions: &[], k: 0, }, - /* 217 - "FixedPointTerm" */ + /* 220 - "FixedPointTerm" */ LookaheadDFA { prod0: 3, transitions: &[], k: 0, }, - /* 218 - "FixedPointToken" */ + /* 221 - "FixedPointToken" */ LookaheadDFA { - prod0: 118, + prod0: 120, transitions: &[], k: 0, }, - /* 219 - "FixedType" */ + /* 222 - "FixedType" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 63, 5, 501), - Trans(0, 64, 6, 502), - Trans(0, 68, 3, 499), - Trans(0, 69, 4, 500), - Trans(0, 104, 7, 503), - Trans(0, 109, 1, 497), - Trans(0, 110, 2, 498), + Trans(0, 64, 5, 507), + Trans(0, 65, 6, 508), + Trans(0, 69, 3, 505), + Trans(0, 70, 4, 506), + Trans(0, 106, 7, 509), + Trans(0, 111, 1, 503), + Trans(0, 112, 2, 504), ], k: 1, }, - /* 220 - "For" */ + /* 223 - "For" */ LookaheadDFA { - prod0: 288, + prod0: 293, transitions: &[], k: 0, }, - /* 221 - "ForStatement" */ + /* 224 - "ForStatement" */ LookaheadDFA { - prod0: 586, + prod0: 591, transitions: &[], k: 0, }, - /* 222 - "ForStatementList" */ + /* 225 - "ForStatementList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 588), - Trans(0, 54, 1, 587), - Trans(0, 66, 1, 587), - Trans(0, 70, 1, 587), - Trans(0, 71, 1, 587), - Trans(0, 81, 1, 587), - Trans(0, 100, 1, 587), - Trans(0, 101, 1, 587), - Trans(0, 106, 1, 587), - Trans(0, 114, 1, 587), - Trans(0, 115, 1, 587), + Trans(0, 44, 2, 593), + Trans(0, 54, 1, 592), + Trans(0, 67, 1, 592), + Trans(0, 71, 1, 592), + Trans(0, 72, 1, 592), + Trans(0, 82, 1, 592), + Trans(0, 102, 1, 592), + Trans(0, 103, 1, 592), + Trans(0, 108, 1, 592), + Trans(0, 116, 1, 592), + Trans(0, 117, 1, 592), ], k: 1, }, - /* 223 - "ForStatementOpt" */ + /* 226 - "ForStatementOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 2, 590), Trans(0, 103, 1, 589)], + transitions: &[Trans(0, 40, 2, 595), Trans(0, 105, 1, 594)], k: 1, }, - /* 224 - "ForTerm" */ + /* 227 - "ForTerm" */ LookaheadDFA { - prod0: 61, + prod0: 62, transitions: &[], k: 0, }, - /* 225 - "ForToken" */ + /* 228 - "ForToken" */ LookaheadDFA { - prod0: 176, + prod0: 179, transitions: &[], k: 0, }, - /* 226 - "Function" */ + /* 229 - "Function" */ LookaheadDFA { - prod0: 289, + prod0: 294, transitions: &[], k: 0, }, - /* 227 - "FunctionCall" */ + /* 230 - "FunctionCall" */ LookaheadDFA { - prod0: 429, + prod0: 435, transitions: &[], k: 0, }, - /* 228 - "FunctionCallOpt" */ + /* 231 - "FunctionCallOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 430), - Trans(0, 7, 1, 430), - Trans(0, 8, 1, 430), - Trans(0, 9, 1, 430), - Trans(0, 10, 1, 430), - Trans(0, 11, 1, 430), - Trans(0, 18, 1, 430), - Trans(0, 24, 1, 430), - Trans(0, 25, 1, 430), - Trans(0, 26, 1, 430), - Trans(0, 27, 1, 430), - Trans(0, 39, 1, 430), - Trans(0, 40, 1, 430), - Trans(0, 42, 1, 430), - Trans(0, 46, 2, 431), - Trans(0, 54, 1, 430), - Trans(0, 71, 1, 430), - Trans(0, 77, 1, 430), - Trans(0, 84, 1, 430), - Trans(0, 87, 1, 430), - Trans(0, 89, 1, 430), - Trans(0, 106, 1, 430), - Trans(0, 114, 1, 430), - Trans(0, 115, 1, 430), + Trans(0, 6, 1, 436), + Trans(0, 7, 1, 436), + Trans(0, 8, 1, 436), + Trans(0, 9, 1, 436), + Trans(0, 10, 1, 436), + Trans(0, 11, 1, 436), + Trans(0, 18, 1, 436), + Trans(0, 24, 1, 436), + Trans(0, 25, 1, 436), + Trans(0, 26, 1, 436), + Trans(0, 27, 1, 436), + Trans(0, 39, 1, 436), + Trans(0, 40, 1, 436), + Trans(0, 42, 1, 436), + Trans(0, 46, 2, 437), + Trans(0, 54, 1, 436), + Trans(0, 72, 1, 436), + Trans(0, 78, 1, 436), + Trans(0, 85, 1, 436), + Trans(0, 88, 1, 436), + Trans(0, 90, 1, 436), + Trans(0, 108, 1, 436), + Trans(0, 116, 1, 436), + Trans(0, 117, 1, 436), ], k: 1, }, - /* 229 - "FunctionDeclaration" */ + /* 232 - "FunctionDeclaration" */ LookaheadDFA { - prod0: 806, + prod0: 814, transitions: &[], k: 0, }, - /* 230 - "FunctionDeclarationList" */ + /* 233 - "FunctionDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 808), - Trans(0, 54, 1, 807), - Trans(0, 66, 1, 807), - Trans(0, 70, 1, 807), - Trans(0, 71, 1, 807), - Trans(0, 81, 1, 807), - Trans(0, 100, 1, 807), - Trans(0, 101, 1, 807), - Trans(0, 106, 1, 807), - Trans(0, 113, 1, 807), - Trans(0, 114, 1, 807), - Trans(0, 115, 1, 807), + Trans(0, 44, 2, 816), + Trans(0, 54, 1, 815), + Trans(0, 67, 1, 815), + Trans(0, 71, 1, 815), + Trans(0, 72, 1, 815), + Trans(0, 82, 1, 815), + Trans(0, 102, 1, 815), + Trans(0, 103, 1, 815), + Trans(0, 108, 1, 815), + Trans(0, 115, 1, 815), + Trans(0, 116, 1, 815), + Trans(0, 117, 1, 815), ], k: 1, }, - /* 231 - "FunctionDeclarationOpt" */ + /* 234 - "FunctionDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 13, 2, 814), - Trans(0, 29, 1, 813), - Trans(0, 40, 2, 814), - Trans(0, 42, 2, 814), + Trans(0, 13, 2, 822), + Trans(0, 29, 1, 821), + Trans(0, 40, 2, 822), + Trans(0, 42, 2, 822), ], k: 1, }, - /* 232 - "FunctionDeclarationOpt0" */ + /* 235 - "FunctionDeclarationOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 13, 2, 812), - Trans(0, 40, 2, 812), - Trans(0, 42, 1, 811), + Trans(0, 13, 2, 820), + Trans(0, 40, 2, 820), + Trans(0, 42, 1, 819), ], k: 1, }, - /* 233 - "FunctionDeclarationOpt1" */ + /* 236 - "FunctionDeclarationOpt1" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 13, 1, 809), Trans(0, 40, 2, 810)], + transitions: &[Trans(0, 13, 1, 817), Trans(0, 40, 2, 818)], k: 1, }, - /* 234 - "FunctionItem" */ + /* 237 - "FunctionItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 54, 2, 816), - Trans(0, 66, 2, 816), - Trans(0, 70, 2, 816), - Trans(0, 71, 2, 816), - Trans(0, 81, 2, 816), - Trans(0, 100, 2, 816), - Trans(0, 101, 2, 816), - Trans(0, 106, 2, 816), - Trans(0, 113, 1, 815), - Trans(0, 114, 2, 816), - Trans(0, 115, 2, 816), + Trans(0, 54, 2, 824), + Trans(0, 67, 2, 824), + Trans(0, 71, 2, 824), + Trans(0, 72, 2, 824), + Trans(0, 82, 2, 824), + Trans(0, 102, 2, 824), + Trans(0, 103, 2, 824), + Trans(0, 108, 2, 824), + Trans(0, 115, 1, 823), + Trans(0, 116, 2, 824), + Trans(0, 117, 2, 824), ], k: 1, }, - /* 235 - "FunctionTerm" */ + /* 238 - "FunctionTerm" */ LookaheadDFA { - prod0: 62, + prod0: 63, transitions: &[], k: 0, }, - /* 236 - "FunctionToken" */ + /* 239 - "FunctionToken" */ LookaheadDFA { - prod0: 177, + prod0: 180, transitions: &[], k: 0, }, - /* 237 - "Hash" */ + /* 240 - "GenericBound" */ LookaheadDFA { - prod0: 255, + prod0: -1, + transitions: &[ + Trans(0, 58, 1, 762), + Trans(0, 110, 2, 763), + Trans(0, 116, 3, 764), + Trans(0, 117, 3, 764), + ], + k: 1, + }, + /* 241 - "Hash" */ + LookaheadDFA { + prod0: 259, transitions: &[], k: 0, }, - /* 238 - "HashTerm" */ + /* 242 - "HashTerm" */ LookaheadDFA { prod0: 32, transitions: &[], k: 0, }, - /* 239 - "HashToken" */ + /* 243 - "HashToken" */ LookaheadDFA { - prod0: 144, + prod0: 146, transitions: &[], k: 0, }, - /* 240 - "HierarchicalIdentifier" */ + /* 244 - "HierarchicalIdentifier" */ LookaheadDFA { - prod0: 344, + prod0: 350, transitions: &[], k: 0, }, - /* 241 - "HierarchicalIdentifierList" */ + /* 245 - "HierarchicalIdentifierList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 2, 350), - Trans(0, 35, 2, 350), - Trans(0, 36, 2, 350), - Trans(0, 41, 1, 349), - Trans(0, 46, 2, 350), + Trans(0, 32, 2, 356), + Trans(0, 35, 2, 356), + Trans(0, 36, 2, 356), + Trans(0, 41, 1, 355), + Trans(0, 46, 2, 356), ], k: 1, }, - /* 242 - "HierarchicalIdentifierList0" */ + /* 246 - "HierarchicalIdentifierList0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 2, 348), - Trans(0, 35, 1, 345), - Trans(0, 36, 2, 348), - Trans(0, 46, 2, 348), + Trans(0, 32, 2, 354), + Trans(0, 35, 1, 351), + Trans(0, 36, 2, 354), + Trans(0, 46, 2, 354), ], k: 1, }, - /* 243 - "HierarchicalIdentifierList0List" */ + /* 247 - "HierarchicalIdentifierList0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 2, 347), - Trans(0, 35, 2, 347), - Trans(0, 36, 2, 347), - Trans(0, 41, 1, 346), - Trans(0, 46, 2, 347), + Trans(0, 32, 2, 353), + Trans(0, 35, 2, 353), + Trans(0, 36, 2, 353), + Trans(0, 41, 1, 352), + Trans(0, 46, 2, 353), ], k: 1, }, - /* 244 - "I32" */ + /* 248 - "I32" */ LookaheadDFA { - prod0: 290, + prod0: 295, transitions: &[], k: 0, }, - /* 245 - "I32Term" */ + /* 249 - "I32Term" */ LookaheadDFA { - prod0: 63, + prod0: 64, transitions: &[], k: 0, }, - /* 246 - "I32Token" */ + /* 250 - "I32Token" */ LookaheadDFA { - prod0: 178, + prod0: 181, transitions: &[], k: 0, }, - /* 247 - "I64" */ + /* 251 - "I64" */ LookaheadDFA { - prod0: 291, + prod0: 296, transitions: &[], k: 0, }, - /* 248 - "I64Term" */ + /* 252 - "I64Term" */ LookaheadDFA { - prod0: 64, + prod0: 65, transitions: &[], k: 0, }, - /* 249 - "I64Token" */ + /* 253 - "I64Token" */ LookaheadDFA { - prod0: 179, + prod0: 182, transitions: &[], k: 0, }, - /* 250 - "Identifier" */ + /* 254 - "Identifier" */ LookaheadDFA { - prod0: 336, + prod0: 342, transitions: &[], k: 0, }, - /* 251 - "IdentifierStatement" */ + /* 255 - "IdentifierStatement" */ LookaheadDFA { - prod0: 556, + prod0: 561, transitions: &[], k: 0, }, - /* 252 - "IdentifierStatementGroup" */ + /* 256 - "IdentifierStatementGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 15, 2, 558), - Trans(0, 36, 2, 558), - Trans(0, 42, 1, 557), + Trans(0, 15, 2, 563), + Trans(0, 36, 2, 563), + Trans(0, 42, 1, 562), ], k: 1, }, - /* 253 - "IdentifierTerm" */ + /* 257 - "IdentifierTerm" */ LookaheadDFA { - prod0: 110, + prod0: 112, transitions: &[], k: 0, }, - /* 254 - "IdentifierToken" */ + /* 258 - "IdentifierToken" */ LookaheadDFA { - prod0: 225, + prod0: 229, transitions: &[], k: 0, }, - /* 255 - "If" */ + /* 259 - "If" */ LookaheadDFA { - prod0: 292, + prod0: 297, transitions: &[], k: 0, }, - /* 256 - "IfExpression" */ + /* 260 - "IfExpression" */ LookaheadDFA { - prod0: 456, + prod0: 462, transitions: &[], k: 0, }, - /* 257 - "IfExpressionList" */ + /* 261 - "IfExpressionList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 59, 1, -1), + Trans(0, 60, 1, -1), Trans(1, 5, 4, -1), Trans(1, 40, 5, -1), - Trans(1, 71, 2, -1), - Trans(2, 5, 3, 457), - Trans(2, 6, 3, 457), - Trans(2, 7, 3, 457), - Trans(2, 8, 3, 457), - Trans(2, 9, 3, 457), - Trans(2, 10, 3, 457), - Trans(2, 11, 3, 457), - Trans(2, 18, 3, 457), - Trans(2, 24, 3, 457), - Trans(2, 25, 3, 457), - Trans(2, 26, 3, 457), - Trans(2, 27, 3, 457), - Trans(2, 39, 3, 457), - Trans(2, 40, 3, 457), - Trans(2, 42, 3, 457), - Trans(2, 54, 3, 457), - Trans(2, 71, 3, 457), - Trans(2, 77, 3, 457), - Trans(2, 84, 3, 457), - Trans(2, 87, 3, 457), - Trans(2, 89, 3, 457), - Trans(2, 106, 3, 457), - Trans(2, 114, 3, 457), - Trans(2, 115, 3, 457), - Trans(4, 40, 6, 458), - Trans(4, 71, 3, 457), - Trans(5, 5, 6, 458), - Trans(5, 6, 6, 458), - Trans(5, 7, 6, 458), - Trans(5, 8, 6, 458), - Trans(5, 9, 6, 458), - Trans(5, 10, 6, 458), - Trans(5, 11, 6, 458), - Trans(5, 18, 6, 458), - Trans(5, 24, 6, 458), - Trans(5, 25, 6, 458), - Trans(5, 26, 6, 458), - Trans(5, 27, 6, 458), - Trans(5, 39, 6, 458), - Trans(5, 40, 6, 458), - Trans(5, 42, 6, 458), - Trans(5, 54, 6, 458), - Trans(5, 71, 6, 458), - Trans(5, 77, 6, 458), - Trans(5, 84, 6, 458), - Trans(5, 87, 6, 458), - Trans(5, 89, 6, 458), - Trans(5, 106, 6, 458), - Trans(5, 114, 6, 458), - Trans(5, 115, 6, 458), + Trans(1, 72, 2, -1), + Trans(2, 5, 3, 463), + Trans(2, 6, 3, 463), + Trans(2, 7, 3, 463), + Trans(2, 8, 3, 463), + Trans(2, 9, 3, 463), + Trans(2, 10, 3, 463), + Trans(2, 11, 3, 463), + Trans(2, 18, 3, 463), + Trans(2, 24, 3, 463), + Trans(2, 25, 3, 463), + Trans(2, 26, 3, 463), + Trans(2, 27, 3, 463), + Trans(2, 39, 3, 463), + Trans(2, 40, 3, 463), + Trans(2, 42, 3, 463), + Trans(2, 54, 3, 463), + Trans(2, 72, 3, 463), + Trans(2, 78, 3, 463), + Trans(2, 85, 3, 463), + Trans(2, 88, 3, 463), + Trans(2, 90, 3, 463), + Trans(2, 108, 3, 463), + Trans(2, 116, 3, 463), + Trans(2, 117, 3, 463), + Trans(4, 40, 6, 464), + Trans(4, 72, 3, 463), + Trans(5, 5, 6, 464), + Trans(5, 6, 6, 464), + Trans(5, 7, 6, 464), + Trans(5, 8, 6, 464), + Trans(5, 9, 6, 464), + Trans(5, 10, 6, 464), + Trans(5, 11, 6, 464), + Trans(5, 18, 6, 464), + Trans(5, 24, 6, 464), + Trans(5, 25, 6, 464), + Trans(5, 26, 6, 464), + Trans(5, 27, 6, 464), + Trans(5, 39, 6, 464), + Trans(5, 40, 6, 464), + Trans(5, 42, 6, 464), + Trans(5, 54, 6, 464), + Trans(5, 72, 6, 464), + Trans(5, 78, 6, 464), + Trans(5, 85, 6, 464), + Trans(5, 88, 6, 464), + Trans(5, 90, 6, 464), + Trans(5, 108, 6, 464), + Trans(5, 116, 6, 464), + Trans(5, 117, 6, 464), ], k: 3, }, - /* 258 - "IfReset" */ + /* 262 - "IfReset" */ LookaheadDFA { - prod0: 293, + prod0: 298, transitions: &[], k: 0, }, - /* 259 - "IfResetStatement" */ + /* 263 - "IfResetStatement" */ LookaheadDFA { - prod0: 573, + prod0: 578, transitions: &[], k: 0, }, - /* 260 - "IfResetStatementList" */ + /* 264 - "IfResetStatementList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 579), - Trans(0, 54, 1, 578), - Trans(0, 66, 1, 578), - Trans(0, 70, 1, 578), - Trans(0, 71, 1, 578), - Trans(0, 81, 1, 578), - Trans(0, 100, 1, 578), - Trans(0, 101, 1, 578), - Trans(0, 106, 1, 578), - Trans(0, 114, 1, 578), - Trans(0, 115, 1, 578), + Trans(0, 44, 2, 584), + Trans(0, 54, 1, 583), + Trans(0, 67, 1, 583), + Trans(0, 71, 1, 583), + Trans(0, 72, 1, 583), + Trans(0, 82, 1, 583), + Trans(0, 102, 1, 583), + Trans(0, 103, 1, 583), + Trans(0, 108, 1, 583), + Trans(0, 116, 1, 583), + Trans(0, 117, 1, 583), ], k: 1, }, - /* 261 - "IfResetStatementList0" */ + /* 265 - "IfResetStatementList0" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -5835,51 +5901,51 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 42, 9, -1), Trans(0, 44, 10, -1), Trans(0, 54, 11, -1), - Trans(0, 58, 12, -1), - Trans(0, 59, 1, -1), - Trans(0, 66, 13, -1), - Trans(0, 70, 14, -1), - Trans(0, 71, 11, -1), - Trans(0, 77, 11, -1), - Trans(0, 81, 13, -1), - Trans(0, 84, 5, -1), - Trans(0, 87, 5, -1), - Trans(0, 89, 11, -1), - Trans(0, 100, 15, -1), - Trans(0, 101, 16, -1), - Trans(0, 106, 17, -1), - Trans(0, 113, 13, -1), - Trans(0, 114, 18, -1), - Trans(0, 115, 19, -1), + Trans(0, 59, 12, -1), + Trans(0, 60, 1, -1), + Trans(0, 67, 13, -1), + Trans(0, 71, 14, -1), + Trans(0, 72, 11, -1), + Trans(0, 78, 11, -1), + Trans(0, 82, 13, -1), + Trans(0, 85, 5, -1), + Trans(0, 88, 5, -1), + Trans(0, 90, 11, -1), + Trans(0, 102, 15, -1), + Trans(0, 103, 16, -1), + Trans(0, 108, 17, -1), + Trans(0, 115, 13, -1), + Trans(0, 116, 18, -1), + Trans(0, 117, 19, -1), Trans(1, 5, 4, -1), Trans(1, 40, 63, -1), - Trans(1, 71, 2, -1), - Trans(2, 5, 3, 574), - Trans(2, 6, 3, 574), - Trans(2, 7, 3, 574), - Trans(2, 8, 3, 574), - Trans(2, 9, 3, 574), - Trans(2, 10, 3, 574), - Trans(2, 11, 3, 574), - Trans(2, 18, 3, 574), - Trans(2, 24, 3, 574), - Trans(2, 25, 3, 574), - Trans(2, 26, 3, 574), - Trans(2, 27, 3, 574), - Trans(2, 39, 3, 574), - Trans(2, 40, 3, 574), - Trans(2, 42, 3, 574), - Trans(2, 54, 3, 574), - Trans(2, 71, 3, 574), - Trans(2, 77, 3, 574), - Trans(2, 84, 3, 574), - Trans(2, 87, 3, 574), - Trans(2, 89, 3, 574), - Trans(2, 106, 3, 574), - Trans(2, 114, 3, 574), - Trans(2, 115, 3, 574), - Trans(4, 40, 38, 577), - Trans(4, 71, 3, 574), + Trans(1, 72, 2, -1), + Trans(2, 5, 3, 579), + Trans(2, 6, 3, 579), + Trans(2, 7, 3, 579), + Trans(2, 8, 3, 579), + Trans(2, 9, 3, 579), + Trans(2, 10, 3, 579), + Trans(2, 11, 3, 579), + Trans(2, 18, 3, 579), + Trans(2, 24, 3, 579), + Trans(2, 25, 3, 579), + Trans(2, 26, 3, 579), + Trans(2, 27, 3, 579), + Trans(2, 39, 3, 579), + Trans(2, 40, 3, 579), + Trans(2, 42, 3, 579), + Trans(2, 54, 3, 579), + Trans(2, 72, 3, 579), + Trans(2, 78, 3, 579), + Trans(2, 85, 3, 579), + Trans(2, 88, 3, 579), + Trans(2, 90, 3, 579), + Trans(2, 108, 3, 579), + Trans(2, 116, 3, 579), + Trans(2, 117, 3, 579), + Trans(4, 40, 38, 582), + Trans(4, 72, 3, 579), Trans(5, 5, 61, -1), Trans(5, 16, 22, -1), Trans(5, 17, 22, -1), @@ -5914,14 +5980,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(6, 40, 22, -1), Trans(6, 42, 22, -1), Trans(6, 54, 22, -1), - Trans(6, 71, 22, -1), - Trans(6, 77, 22, -1), - Trans(6, 84, 21, -1), - Trans(6, 87, 21, -1), - Trans(6, 89, 22, -1), - Trans(6, 106, 28, -1), - Trans(6, 114, 40, -1), - Trans(6, 115, 41, -1), + Trans(6, 72, 22, -1), + Trans(6, 78, 22, -1), + Trans(6, 85, 21, -1), + Trans(6, 88, 21, -1), + Trans(6, 90, 22, -1), + Trans(6, 108, 28, -1), + Trans(6, 116, 40, -1), + Trans(6, 117, 41, -1), Trans(7, 5, 42, -1), Trans(7, 6, 43, -1), Trans(7, 7, 43, -1), @@ -5938,15 +6004,15 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(7, 40, 22, -1), Trans(7, 42, 22, -1), Trans(7, 54, 22, -1), - Trans(7, 58, 30, -1), - Trans(7, 71, 22, -1), - Trans(7, 77, 22, -1), - Trans(7, 84, 43, -1), - Trans(7, 87, 43, -1), - Trans(7, 89, 22, -1), - Trans(7, 106, 28, -1), - Trans(7, 114, 44, -1), - Trans(7, 115, 45, -1), + Trans(7, 59, 30, -1), + Trans(7, 72, 22, -1), + Trans(7, 78, 22, -1), + Trans(7, 85, 43, -1), + Trans(7, 88, 43, -1), + Trans(7, 90, 22, -1), + Trans(7, 108, 28, -1), + Trans(7, 116, 44, -1), + Trans(7, 117, 45, -1), Trans(8, 5, 39, -1), Trans(8, 6, 43, -1), Trans(8, 7, 43, -1), @@ -5963,14 +6029,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(8, 40, 22, -1), Trans(8, 42, 22, -1), Trans(8, 54, 22, -1), - Trans(8, 71, 22, -1), - Trans(8, 77, 22, -1), - Trans(8, 84, 43, -1), - Trans(8, 87, 43, -1), - Trans(8, 89, 22, -1), - Trans(8, 106, 28, -1), - Trans(8, 114, 44, -1), - Trans(8, 115, 45, -1), + Trans(8, 72, 22, -1), + Trans(8, 78, 22, -1), + Trans(8, 85, 43, -1), + Trans(8, 88, 43, -1), + Trans(8, 90, 22, -1), + Trans(8, 108, 28, -1), + Trans(8, 116, 44, -1), + Trans(8, 117, 45, -1), Trans(9, 5, 39, -1), Trans(9, 6, 46, -1), Trans(9, 7, 46, -1), @@ -5987,14 +6053,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(9, 40, 22, -1), Trans(9, 42, 22, -1), Trans(9, 54, 22, -1), - Trans(9, 71, 22, -1), - Trans(9, 77, 22, -1), - Trans(9, 84, 46, -1), - Trans(9, 87, 46, -1), - Trans(9, 89, 22, -1), - Trans(9, 106, 28, -1), - Trans(9, 114, 47, -1), - Trans(9, 115, 48, -1), + Trans(9, 72, 22, -1), + Trans(9, 78, 22, -1), + Trans(9, 85, 46, -1), + Trans(9, 88, 46, -1), + Trans(9, 90, 22, -1), + Trans(9, 108, 28, -1), + Trans(9, 116, 47, -1), + Trans(9, 117, 48, -1), Trans(10, 5, 20, -1), Trans(10, 6, 21, -1), Trans(10, 7, 21, -1), @@ -6017,35 +6083,35 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(10, 50, 29, -1), Trans(10, 51, 23, -1), Trans(10, 54, 22, -1), - Trans(10, 58, 30, -1), - Trans(10, 59, 31, -1), - Trans(10, 61, 23, -1), - Trans(10, 62, 32, -1), - Trans(10, 65, 28, -1), - Trans(10, 66, 23, -1), + Trans(10, 59, 30, -1), + Trans(10, 60, 31, -1), + Trans(10, 62, 23, -1), + Trans(10, 63, 32, -1), + Trans(10, 66, 28, -1), Trans(10, 67, 23, -1), - Trans(10, 70, 28, -1), - Trans(10, 71, 22, -1), - Trans(10, 72, 33, -1), - Trans(10, 74, 28, -1), - Trans(10, 77, 22, -1), - Trans(10, 78, 23, -1), - Trans(10, 81, 23, -1), + Trans(10, 68, 23, -1), + Trans(10, 71, 28, -1), + Trans(10, 72, 22, -1), + Trans(10, 73, 33, -1), + Trans(10, 75, 28, -1), + Trans(10, 78, 22, -1), + Trans(10, 79, 23, -1), Trans(10, 82, 23, -1), - Trans(10, 84, 21, -1), - Trans(10, 85, 23, -1), - Trans(10, 87, 21, -1), - Trans(10, 89, 22, -1), - Trans(10, 100, 22, -1), - Trans(10, 101, 34, -1), - Trans(10, 105, 23, -1), - Trans(10, 106, 28, -1), - Trans(10, 108, 23, -1), - Trans(10, 111, 23, -1), - Trans(10, 112, 35, -1), + Trans(10, 83, 23, -1), + Trans(10, 85, 21, -1), + Trans(10, 86, 23, -1), + Trans(10, 88, 21, -1), + Trans(10, 90, 22, -1), + Trans(10, 102, 22, -1), + Trans(10, 103, 34, -1), + Trans(10, 107, 23, -1), + Trans(10, 108, 28, -1), + Trans(10, 110, 23, -1), Trans(10, 113, 23, -1), - Trans(10, 114, 36, -1), - Trans(10, 115, 37, -1), + Trans(10, 114, 35, -1), + Trans(10, 115, 23, -1), + Trans(10, 116, 36, -1), + Trans(10, 117, 37, -1), Trans(11, 5, 39, -1), Trans(11, 6, 49, -1), Trans(11, 7, 49, -1), @@ -6062,18 +6128,18 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(11, 40, 22, -1), Trans(11, 42, 22, -1), Trans(11, 54, 22, -1), - Trans(11, 71, 22, -1), - Trans(11, 77, 22, -1), - Trans(11, 84, 49, -1), - Trans(11, 87, 49, -1), - Trans(11, 89, 22, -1), - Trans(11, 106, 28, -1), - Trans(11, 114, 50, -1), - Trans(11, 115, 51, -1), + Trans(11, 72, 22, -1), + Trans(11, 78, 22, -1), + Trans(11, 85, 49, -1), + Trans(11, 88, 49, -1), + Trans(11, 90, 22, -1), + Trans(11, 108, 28, -1), + Trans(11, 116, 50, -1), + Trans(11, 117, 51, -1), Trans(12, 5, 62, -1), Trans(12, 31, 56, -1), Trans(13, 5, 68, -1), - Trans(13, 115, 30, -1), + Trans(13, 117, 30, -1), Trans(14, 5, 64, -1), Trans(14, 40, 63, -1), Trans(15, 5, 39, -1), @@ -6092,14 +6158,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(15, 40, 22, -1), Trans(15, 42, 22, -1), Trans(15, 54, 22, -1), - Trans(15, 71, 22, -1), - Trans(15, 77, 22, -1), - Trans(15, 84, 52, -1), - Trans(15, 87, 52, -1), - Trans(15, 89, 22, -1), - Trans(15, 106, 28, -1), - Trans(15, 114, 53, -1), - Trans(15, 115, 54, -1), + Trans(15, 72, 22, -1), + Trans(15, 78, 22, -1), + Trans(15, 85, 52, -1), + Trans(15, 88, 52, -1), + Trans(15, 90, 22, -1), + Trans(15, 108, 28, -1), + Trans(15, 116, 53, -1), + Trans(15, 117, 54, -1), Trans(16, 5, 66, -1), Trans(16, 47, 67, -1), Trans(17, 5, 64, -1), @@ -6153,912 +6219,913 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(19, 42, 57, -1), Trans(19, 48, 22, -1), Trans(19, 52, 58, -1), - Trans(20, 6, 38, 577), - Trans(20, 7, 38, 577), - Trans(20, 8, 38, 577), - Trans(20, 9, 38, 577), - Trans(20, 10, 38, 577), - Trans(20, 11, 38, 577), - Trans(20, 18, 38, 577), - Trans(20, 24, 38, 577), - Trans(20, 25, 38, 577), - Trans(20, 26, 38, 577), - Trans(20, 27, 38, 577), - Trans(20, 31, 38, 577), - Trans(20, 37, 38, 577), - Trans(20, 39, 38, 577), - Trans(20, 40, 38, 577), - Trans(20, 42, 38, 577), - Trans(20, 44, 38, 577), - Trans(20, 49, 38, 577), - Trans(20, 50, 38, 577), - Trans(20, 51, 38, 577), - Trans(20, 54, 38, 577), - Trans(20, 58, 38, 577), - Trans(20, 59, 38, 577), - Trans(20, 61, 38, 577), - Trans(20, 62, 38, 577), - Trans(20, 65, 38, 577), - Trans(20, 66, 38, 577), - Trans(20, 67, 38, 577), - Trans(20, 70, 38, 577), - Trans(20, 71, 38, 577), - Trans(20, 72, 38, 577), - Trans(20, 74, 38, 577), - Trans(20, 77, 38, 577), - Trans(20, 78, 38, 577), - Trans(20, 81, 38, 577), - Trans(20, 82, 38, 577), - Trans(20, 84, 38, 577), - Trans(20, 85, 38, 577), - Trans(20, 87, 38, 577), - Trans(20, 89, 38, 577), - Trans(20, 100, 38, 577), - Trans(20, 101, 38, 577), - Trans(20, 105, 38, 577), - Trans(20, 106, 38, 577), - Trans(20, 108, 38, 577), - Trans(20, 111, 38, 577), - Trans(20, 112, 38, 577), - Trans(20, 113, 38, 577), - Trans(20, 114, 38, 577), - Trans(20, 115, 38, 577), - Trans(21, 5, 38, 577), - Trans(21, 16, 38, 577), - Trans(21, 17, 38, 577), - Trans(21, 18, 38, 577), - Trans(21, 19, 38, 577), - Trans(21, 20, 38, 577), - Trans(21, 21, 38, 577), - Trans(21, 22, 38, 577), - Trans(21, 23, 38, 577), - Trans(21, 24, 38, 577), - Trans(21, 25, 38, 577), - Trans(21, 26, 38, 577), - Trans(21, 31, 38, 577), - Trans(21, 32, 38, 577), - Trans(21, 33, 38, 577), - Trans(21, 34, 38, 577), - Trans(21, 48, 38, 577), - Trans(21, 52, 38, 577), - Trans(22, 5, 38, 577), - Trans(22, 6, 38, 577), - Trans(22, 7, 38, 577), - Trans(22, 8, 38, 577), - Trans(22, 9, 38, 577), - Trans(22, 10, 38, 577), - Trans(22, 11, 38, 577), - Trans(22, 18, 38, 577), - Trans(22, 24, 38, 577), - Trans(22, 25, 38, 577), - Trans(22, 26, 38, 577), - Trans(22, 27, 38, 577), - Trans(22, 39, 38, 577), - Trans(22, 40, 38, 577), - Trans(22, 42, 38, 577), - Trans(22, 54, 38, 577), - Trans(22, 71, 38, 577), - Trans(22, 77, 38, 577), - Trans(22, 84, 38, 577), - Trans(22, 87, 38, 577), - Trans(22, 89, 38, 577), - Trans(22, 106, 38, 577), - Trans(22, 114, 38, 577), - Trans(22, 115, 38, 577), - Trans(23, 5, 38, 577), - Trans(23, 115, 38, 577), - Trans(24, 5, 38, 577), - Trans(24, 41, 38, 577), - Trans(25, 5, 38, 577), - Trans(25, 6, 38, 577), - Trans(25, 7, 38, 577), - Trans(25, 8, 38, 577), - Trans(25, 9, 38, 577), - Trans(25, 10, 38, 577), - Trans(25, 11, 38, 577), - Trans(25, 18, 38, 577), - Trans(25, 24, 38, 577), - Trans(25, 25, 38, 577), - Trans(25, 26, 38, 577), - Trans(25, 27, 38, 577), - Trans(25, 39, 38, 577), - Trans(25, 40, 38, 577), - Trans(25, 42, 38, 577), - Trans(25, 54, 38, 577), - Trans(25, 58, 38, 577), - Trans(25, 71, 38, 577), - Trans(25, 77, 38, 577), - Trans(25, 84, 38, 577), - Trans(25, 87, 38, 577), - Trans(25, 89, 38, 577), - Trans(25, 106, 38, 577), - Trans(25, 114, 38, 577), - Trans(25, 115, 38, 577), - Trans(26, 5, 38, 577), - Trans(26, 6, 38, 577), - Trans(26, 7, 38, 577), - Trans(26, 8, 38, 577), - Trans(26, 9, 38, 577), - Trans(26, 10, 38, 577), - Trans(26, 11, 38, 577), - Trans(26, 18, 38, 577), - Trans(26, 24, 38, 577), - Trans(26, 25, 38, 577), - Trans(26, 26, 38, 577), - Trans(26, 27, 38, 577), - Trans(26, 31, 38, 577), - Trans(26, 37, 38, 577), - Trans(26, 39, 38, 577), - Trans(26, 40, 38, 577), - Trans(26, 42, 38, 577), - Trans(26, 44, 38, 577), - Trans(26, 49, 38, 577), - Trans(26, 50, 38, 577), - Trans(26, 51, 38, 577), - Trans(26, 54, 38, 577), - Trans(26, 61, 38, 577), - Trans(26, 62, 38, 577), - Trans(26, 65, 38, 577), - Trans(26, 66, 38, 577), - Trans(26, 67, 38, 577), - Trans(26, 71, 38, 577), - Trans(26, 72, 38, 577), - Trans(26, 74, 38, 577), - Trans(26, 77, 38, 577), - Trans(26, 78, 38, 577), - Trans(26, 81, 38, 577), - Trans(26, 82, 38, 577), - Trans(26, 84, 38, 577), - Trans(26, 85, 38, 577), - Trans(26, 87, 38, 577), - Trans(26, 89, 38, 577), - Trans(26, 105, 38, 577), - Trans(26, 106, 38, 577), - Trans(26, 108, 38, 577), - Trans(26, 111, 38, 577), - Trans(26, 112, 38, 577), - Trans(26, 113, 38, 577), - Trans(26, 114, 38, 577), - Trans(26, 115, 38, 577), - Trans(27, 0, 38, 577), - Trans(27, 5, 38, 577), - Trans(27, 6, 38, 577), - Trans(27, 7, 38, 577), - Trans(27, 8, 38, 577), - Trans(27, 9, 38, 577), - Trans(27, 10, 38, 577), - Trans(27, 11, 38, 577), - Trans(27, 18, 38, 577), - Trans(27, 24, 38, 577), - Trans(27, 25, 38, 577), - Trans(27, 26, 38, 577), - Trans(27, 27, 38, 577), - Trans(27, 31, 38, 577), - Trans(27, 37, 38, 577), - Trans(27, 39, 38, 577), - Trans(27, 40, 38, 577), - Trans(27, 42, 38, 577), - Trans(27, 44, 38, 577), - Trans(27, 49, 38, 577), - Trans(27, 50, 38, 577), - Trans(27, 51, 38, 577), - Trans(27, 54, 38, 577), - Trans(27, 58, 38, 577), - Trans(27, 59, 38, 577), - Trans(27, 60, 38, 577), - Trans(27, 61, 38, 577), - Trans(27, 62, 38, 577), - Trans(27, 65, 38, 577), - Trans(27, 66, 38, 577), - Trans(27, 67, 38, 577), - Trans(27, 70, 38, 577), - Trans(27, 71, 38, 577), - Trans(27, 72, 38, 577), - Trans(27, 73, 38, 577), - Trans(27, 74, 38, 577), - Trans(27, 77, 38, 577), - Trans(27, 78, 38, 577), - Trans(27, 79, 38, 577), - Trans(27, 81, 38, 577), - Trans(27, 82, 38, 577), - Trans(27, 84, 38, 577), - Trans(27, 85, 38, 577), - Trans(27, 86, 38, 577), - Trans(27, 87, 38, 577), - Trans(27, 89, 38, 577), - Trans(27, 90, 38, 577), - Trans(27, 92, 38, 577), - Trans(27, 100, 38, 577), - Trans(27, 101, 38, 577), - Trans(27, 105, 38, 577), - Trans(27, 106, 38, 577), - Trans(27, 108, 38, 577), - Trans(27, 111, 38, 577), - Trans(27, 112, 38, 577), - Trans(27, 113, 38, 577), - Trans(27, 114, 38, 577), - Trans(27, 115, 38, 577), - Trans(28, 5, 38, 577), - Trans(28, 40, 38, 577), - Trans(29, 5, 38, 577), - Trans(29, 40, 38, 577), - Trans(29, 42, 38, 577), - Trans(30, 5, 38, 577), - Trans(30, 31, 38, 577), - Trans(31, 5, 38, 577), - Trans(31, 40, 38, 577), - Trans(31, 71, 38, 577), - Trans(32, 5, 38, 577), - Trans(32, 48, 38, 577), - Trans(32, 114, 38, 577), - Trans(32, 115, 38, 577), - Trans(33, 5, 38, 577), - Trans(33, 114, 38, 577), - Trans(33, 115, 38, 577), - Trans(34, 5, 38, 577), - Trans(34, 47, 38, 577), - Trans(35, 5, 38, 577), - Trans(35, 42, 38, 577), - Trans(36, 5, 38, 577), - Trans(36, 15, 38, 577), - Trans(36, 16, 38, 577), - Trans(36, 17, 38, 577), - Trans(36, 18, 38, 577), - Trans(36, 19, 38, 577), - Trans(36, 20, 38, 577), - Trans(36, 21, 38, 577), - Trans(36, 22, 38, 577), - Trans(36, 23, 38, 577), - Trans(36, 24, 38, 577), - Trans(36, 25, 38, 577), - Trans(36, 26, 38, 577), - Trans(36, 30, 38, 577), - Trans(36, 31, 38, 577), - Trans(36, 32, 38, 577), - Trans(36, 33, 38, 577), - Trans(36, 34, 38, 577), - Trans(36, 35, 38, 577), - Trans(36, 36, 38, 577), - Trans(36, 41, 38, 577), - Trans(36, 42, 38, 577), - Trans(36, 48, 38, 577), - Trans(36, 52, 38, 577), - Trans(37, 5, 38, 577), - Trans(37, 15, 38, 577), - Trans(37, 16, 38, 577), - Trans(37, 17, 38, 577), - Trans(37, 18, 38, 577), - Trans(37, 19, 38, 577), - Trans(37, 20, 38, 577), - Trans(37, 21, 38, 577), - Trans(37, 22, 38, 577), - Trans(37, 23, 38, 577), - Trans(37, 24, 38, 577), - Trans(37, 25, 38, 577), - Trans(37, 26, 38, 577), - Trans(37, 29, 38, 577), - Trans(37, 30, 38, 577), - Trans(37, 31, 38, 577), - Trans(37, 32, 38, 577), - Trans(37, 33, 38, 577), - Trans(37, 34, 38, 577), - Trans(37, 35, 38, 577), - Trans(37, 36, 38, 577), - Trans(37, 41, 38, 577), - Trans(37, 42, 38, 577), - Trans(37, 48, 38, 577), - Trans(37, 52, 38, 577), - Trans(39, 6, 38, 577), - Trans(39, 7, 38, 577), - Trans(39, 8, 38, 577), - Trans(39, 9, 38, 577), - Trans(39, 10, 38, 577), - Trans(39, 11, 38, 577), - Trans(39, 18, 38, 577), - Trans(39, 24, 38, 577), - Trans(39, 25, 38, 577), - Trans(39, 26, 38, 577), - Trans(39, 27, 38, 577), - Trans(39, 39, 38, 577), - Trans(39, 40, 38, 577), - Trans(39, 42, 38, 577), - Trans(39, 54, 38, 577), - Trans(39, 71, 38, 577), - Trans(39, 77, 38, 577), - Trans(39, 84, 38, 577), - Trans(39, 87, 38, 577), - Trans(39, 89, 38, 577), - Trans(39, 106, 38, 577), - Trans(39, 114, 38, 577), - Trans(39, 115, 38, 577), - Trans(40, 5, 38, 577), - Trans(40, 16, 38, 577), - Trans(40, 17, 38, 577), - Trans(40, 18, 38, 577), - Trans(40, 19, 38, 577), - Trans(40, 20, 38, 577), - Trans(40, 21, 38, 577), - Trans(40, 22, 38, 577), - Trans(40, 23, 38, 577), - Trans(40, 24, 38, 577), - Trans(40, 25, 38, 577), - Trans(40, 26, 38, 577), - Trans(40, 30, 38, 577), - Trans(40, 31, 38, 577), - Trans(40, 32, 38, 577), - Trans(40, 33, 38, 577), - Trans(40, 34, 38, 577), - Trans(40, 35, 38, 577), - Trans(40, 41, 38, 577), - Trans(40, 42, 38, 577), - Trans(40, 48, 38, 577), - Trans(40, 52, 38, 577), - Trans(41, 5, 38, 577), - Trans(41, 16, 38, 577), - Trans(41, 17, 38, 577), - Trans(41, 18, 38, 577), - Trans(41, 19, 38, 577), - Trans(41, 20, 38, 577), - Trans(41, 21, 38, 577), - Trans(41, 22, 38, 577), - Trans(41, 23, 38, 577), - Trans(41, 24, 38, 577), - Trans(41, 25, 38, 577), - Trans(41, 26, 38, 577), - Trans(41, 29, 38, 577), - Trans(41, 30, 38, 577), - Trans(41, 31, 38, 577), - Trans(41, 32, 38, 577), - Trans(41, 33, 38, 577), - Trans(41, 34, 38, 577), - Trans(41, 35, 38, 577), - Trans(41, 41, 38, 577), - Trans(41, 42, 38, 577), - Trans(41, 48, 38, 577), - Trans(41, 52, 38, 577), - Trans(42, 6, 38, 577), - Trans(42, 7, 38, 577), - Trans(42, 8, 38, 577), - Trans(42, 9, 38, 577), - Trans(42, 10, 38, 577), - Trans(42, 11, 38, 577), - Trans(42, 18, 38, 577), - Trans(42, 24, 38, 577), - Trans(42, 25, 38, 577), - Trans(42, 26, 38, 577), - Trans(42, 27, 38, 577), - Trans(42, 39, 38, 577), - Trans(42, 40, 38, 577), - Trans(42, 42, 38, 577), - Trans(42, 54, 38, 577), - Trans(42, 58, 38, 577), - Trans(42, 71, 38, 577), - Trans(42, 77, 38, 577), - Trans(42, 84, 38, 577), - Trans(42, 87, 38, 577), - Trans(42, 89, 38, 577), - Trans(42, 106, 38, 577), - Trans(42, 114, 38, 577), - Trans(42, 115, 38, 577), - Trans(43, 5, 38, 577), - Trans(43, 16, 38, 577), - Trans(43, 17, 38, 577), - Trans(43, 18, 38, 577), - Trans(43, 19, 38, 577), - Trans(43, 20, 38, 577), - Trans(43, 21, 38, 577), - Trans(43, 22, 38, 577), - Trans(43, 23, 38, 577), - Trans(43, 24, 38, 577), - Trans(43, 25, 38, 577), - Trans(43, 26, 38, 577), - Trans(43, 32, 38, 577), - Trans(43, 44, 38, 577), - Trans(43, 48, 38, 577), - Trans(43, 52, 38, 577), - Trans(43, 94, 38, 577), - Trans(44, 5, 38, 577), - Trans(44, 16, 38, 577), - Trans(44, 17, 38, 577), - Trans(44, 18, 38, 577), - Trans(44, 19, 38, 577), - Trans(44, 20, 38, 577), - Trans(44, 21, 38, 577), - Trans(44, 22, 38, 577), - Trans(44, 23, 38, 577), - Trans(44, 24, 38, 577), - Trans(44, 25, 38, 577), - Trans(44, 26, 38, 577), - Trans(44, 30, 38, 577), - Trans(44, 32, 38, 577), - Trans(44, 35, 38, 577), - Trans(44, 41, 38, 577), - Trans(44, 42, 38, 577), - Trans(44, 44, 38, 577), - Trans(44, 48, 38, 577), - Trans(44, 52, 38, 577), - Trans(44, 94, 38, 577), - Trans(45, 5, 38, 577), - Trans(45, 16, 38, 577), - Trans(45, 17, 38, 577), - Trans(45, 18, 38, 577), - Trans(45, 19, 38, 577), - Trans(45, 20, 38, 577), - Trans(45, 21, 38, 577), - Trans(45, 22, 38, 577), - Trans(45, 23, 38, 577), - Trans(45, 24, 38, 577), - Trans(45, 25, 38, 577), - Trans(45, 26, 38, 577), - Trans(45, 29, 38, 577), - Trans(45, 30, 38, 577), - Trans(45, 32, 38, 577), - Trans(45, 35, 38, 577), - Trans(45, 41, 38, 577), - Trans(45, 42, 38, 577), - Trans(45, 44, 38, 577), - Trans(45, 48, 38, 577), - Trans(45, 52, 38, 577), - Trans(45, 94, 38, 577), - Trans(46, 5, 38, 577), - Trans(46, 16, 38, 577), - Trans(46, 17, 38, 577), - Trans(46, 18, 38, 577), - Trans(46, 19, 38, 577), - Trans(46, 20, 38, 577), - Trans(46, 21, 38, 577), - Trans(46, 22, 38, 577), - Trans(46, 23, 38, 577), - Trans(46, 24, 38, 577), - Trans(46, 25, 38, 577), - Trans(46, 26, 38, 577), - Trans(46, 46, 38, 577), - Trans(46, 48, 38, 577), - Trans(46, 52, 38, 577), - Trans(47, 5, 38, 577), - Trans(47, 16, 38, 577), - Trans(47, 17, 38, 577), - Trans(47, 18, 38, 577), - Trans(47, 19, 38, 577), - Trans(47, 20, 38, 577), - Trans(47, 21, 38, 577), - Trans(47, 22, 38, 577), - Trans(47, 23, 38, 577), - Trans(47, 24, 38, 577), - Trans(47, 25, 38, 577), - Trans(47, 26, 38, 577), - Trans(47, 30, 38, 577), - Trans(47, 35, 38, 577), - Trans(47, 41, 38, 577), - Trans(47, 42, 38, 577), - Trans(47, 46, 38, 577), - Trans(47, 48, 38, 577), - Trans(47, 52, 38, 577), - Trans(48, 5, 38, 577), - Trans(48, 16, 38, 577), - Trans(48, 17, 38, 577), - Trans(48, 18, 38, 577), - Trans(48, 19, 38, 577), - Trans(48, 20, 38, 577), - Trans(48, 21, 38, 577), - Trans(48, 22, 38, 577), - Trans(48, 23, 38, 577), - Trans(48, 24, 38, 577), - Trans(48, 25, 38, 577), - Trans(48, 26, 38, 577), - Trans(48, 29, 38, 577), - Trans(48, 30, 38, 577), - Trans(48, 35, 38, 577), - Trans(48, 41, 38, 577), - Trans(48, 42, 38, 577), - Trans(48, 46, 38, 577), - Trans(48, 48, 38, 577), - Trans(48, 52, 38, 577), - Trans(49, 5, 38, 577), - Trans(49, 16, 38, 577), - Trans(49, 17, 38, 577), - Trans(49, 18, 38, 577), - Trans(49, 19, 38, 577), - Trans(49, 20, 38, 577), - Trans(49, 21, 38, 577), - Trans(49, 22, 38, 577), - Trans(49, 23, 38, 577), - Trans(49, 24, 38, 577), - Trans(49, 25, 38, 577), - Trans(49, 26, 38, 577), - Trans(49, 40, 38, 577), - Trans(49, 48, 38, 577), - Trans(49, 52, 38, 577), - Trans(50, 5, 38, 577), - Trans(50, 16, 38, 577), - Trans(50, 17, 38, 577), - Trans(50, 18, 38, 577), - Trans(50, 19, 38, 577), - Trans(50, 20, 38, 577), - Trans(50, 21, 38, 577), - Trans(50, 22, 38, 577), - Trans(50, 23, 38, 577), - Trans(50, 24, 38, 577), - Trans(50, 25, 38, 577), - Trans(50, 26, 38, 577), - Trans(50, 30, 38, 577), - Trans(50, 35, 38, 577), - Trans(50, 40, 38, 577), - Trans(50, 41, 38, 577), - Trans(50, 42, 38, 577), - Trans(50, 48, 38, 577), - Trans(50, 52, 38, 577), - Trans(51, 5, 38, 577), - Trans(51, 16, 38, 577), - Trans(51, 17, 38, 577), - Trans(51, 18, 38, 577), - Trans(51, 19, 38, 577), - Trans(51, 20, 38, 577), - Trans(51, 21, 38, 577), - Trans(51, 22, 38, 577), - Trans(51, 23, 38, 577), - Trans(51, 24, 38, 577), - Trans(51, 25, 38, 577), - Trans(51, 26, 38, 577), - Trans(51, 29, 38, 577), - Trans(51, 30, 38, 577), - Trans(51, 35, 38, 577), - Trans(51, 40, 38, 577), - Trans(51, 41, 38, 577), - Trans(51, 42, 38, 577), - Trans(51, 48, 38, 577), - Trans(51, 52, 38, 577), - Trans(52, 5, 38, 577), - Trans(52, 16, 38, 577), - Trans(52, 17, 38, 577), - Trans(52, 18, 38, 577), - Trans(52, 19, 38, 577), - Trans(52, 20, 38, 577), - Trans(52, 21, 38, 577), - Trans(52, 22, 38, 577), - Trans(52, 23, 38, 577), - Trans(52, 24, 38, 577), - Trans(52, 25, 38, 577), - Trans(52, 26, 38, 577), - Trans(52, 47, 38, 577), - Trans(52, 48, 38, 577), - Trans(52, 52, 38, 577), - Trans(53, 5, 38, 577), - Trans(53, 16, 38, 577), - Trans(53, 17, 38, 577), - Trans(53, 18, 38, 577), - Trans(53, 19, 38, 577), - Trans(53, 20, 38, 577), - Trans(53, 21, 38, 577), - Trans(53, 22, 38, 577), - Trans(53, 23, 38, 577), - Trans(53, 24, 38, 577), - Trans(53, 25, 38, 577), - Trans(53, 26, 38, 577), - Trans(53, 30, 38, 577), - Trans(53, 35, 38, 577), - Trans(53, 41, 38, 577), - Trans(53, 42, 38, 577), - Trans(53, 47, 38, 577), - Trans(53, 48, 38, 577), - Trans(53, 52, 38, 577), - Trans(54, 5, 38, 577), - Trans(54, 16, 38, 577), - Trans(54, 17, 38, 577), - Trans(54, 18, 38, 577), - Trans(54, 19, 38, 577), - Trans(54, 20, 38, 577), - Trans(54, 21, 38, 577), - Trans(54, 22, 38, 577), - Trans(54, 23, 38, 577), - Trans(54, 24, 38, 577), - Trans(54, 25, 38, 577), - Trans(54, 26, 38, 577), - Trans(54, 29, 38, 577), - Trans(54, 30, 38, 577), - Trans(54, 35, 38, 577), - Trans(54, 41, 38, 577), - Trans(54, 42, 38, 577), - Trans(54, 47, 38, 577), - Trans(54, 48, 38, 577), - Trans(54, 52, 38, 577), - Trans(55, 15, 38, 577), - Trans(55, 16, 38, 577), - Trans(55, 17, 38, 577), - Trans(55, 18, 38, 577), - Trans(55, 19, 38, 577), - Trans(55, 20, 38, 577), - Trans(55, 21, 38, 577), - Trans(55, 22, 38, 577), - Trans(55, 23, 38, 577), - Trans(55, 24, 38, 577), - Trans(55, 25, 38, 577), - Trans(55, 26, 38, 577), - Trans(55, 30, 38, 577), - Trans(55, 31, 38, 577), - Trans(55, 32, 38, 577), - Trans(55, 33, 38, 577), - Trans(55, 34, 38, 577), - Trans(55, 35, 38, 577), - Trans(55, 36, 38, 577), - Trans(55, 41, 38, 577), - Trans(55, 42, 38, 577), - Trans(55, 48, 38, 577), - Trans(55, 52, 38, 577), - Trans(56, 5, 38, 577), - Trans(56, 40, 38, 577), - Trans(56, 54, 38, 577), - Trans(56, 66, 38, 577), - Trans(56, 70, 38, 577), - Trans(56, 71, 38, 577), - Trans(56, 81, 38, 577), - Trans(56, 100, 38, 577), - Trans(56, 101, 38, 577), - Trans(56, 106, 38, 577), - Trans(56, 114, 38, 577), - Trans(56, 115, 38, 577), - Trans(57, 5, 38, 577), - Trans(57, 6, 38, 577), - Trans(57, 7, 38, 577), - Trans(57, 8, 38, 577), - Trans(57, 9, 38, 577), - Trans(57, 10, 38, 577), - Trans(57, 11, 38, 577), - Trans(57, 18, 38, 577), - Trans(57, 24, 38, 577), - Trans(57, 25, 38, 577), - Trans(57, 26, 38, 577), - Trans(57, 27, 38, 577), - Trans(57, 39, 38, 577), - Trans(57, 40, 38, 577), - Trans(57, 42, 38, 577), - Trans(57, 46, 38, 577), - Trans(57, 54, 38, 577), - Trans(57, 71, 38, 577), - Trans(57, 77, 38, 577), - Trans(57, 84, 38, 577), - Trans(57, 87, 38, 577), - Trans(57, 89, 38, 577), - Trans(57, 106, 38, 577), - Trans(57, 114, 38, 577), - Trans(57, 115, 38, 577), - Trans(58, 5, 38, 577), - Trans(58, 55, 38, 577), - Trans(58, 56, 38, 577), - Trans(58, 57, 38, 577), - Trans(58, 63, 38, 577), - Trans(58, 64, 38, 577), - Trans(58, 68, 38, 577), - Trans(58, 69, 38, 577), - Trans(58, 95, 38, 577), - Trans(58, 96, 38, 577), - Trans(58, 97, 38, 577), - Trans(58, 98, 38, 577), - Trans(58, 99, 38, 577), - Trans(58, 109, 38, 577), - Trans(58, 110, 38, 577), - Trans(58, 114, 38, 577), - Trans(58, 115, 38, 577), - Trans(59, 15, 38, 577), - Trans(59, 16, 38, 577), - Trans(59, 17, 38, 577), - Trans(59, 18, 38, 577), - Trans(59, 19, 38, 577), - Trans(59, 20, 38, 577), - Trans(59, 21, 38, 577), - Trans(59, 22, 38, 577), - Trans(59, 23, 38, 577), - Trans(59, 24, 38, 577), - Trans(59, 25, 38, 577), - Trans(59, 26, 38, 577), - Trans(59, 29, 38, 577), - Trans(59, 30, 38, 577), - Trans(59, 31, 38, 577), - Trans(59, 32, 38, 577), - Trans(59, 33, 38, 577), - Trans(59, 34, 38, 577), - Trans(59, 35, 38, 577), - Trans(59, 36, 38, 577), - Trans(59, 41, 38, 577), - Trans(59, 42, 38, 577), - Trans(59, 48, 38, 577), - Trans(59, 52, 38, 577), - Trans(60, 5, 38, 577), - Trans(60, 7, 38, 577), - Trans(60, 8, 38, 577), - Trans(60, 9, 38, 577), - Trans(60, 10, 38, 577), - Trans(60, 11, 38, 577), - Trans(60, 43, 38, 577), - Trans(60, 114, 38, 577), - Trans(60, 115, 38, 577), - Trans(61, 16, 38, 577), - Trans(61, 17, 38, 577), - Trans(61, 18, 38, 577), - Trans(61, 19, 38, 577), - Trans(61, 20, 38, 577), - Trans(61, 21, 38, 577), - Trans(61, 22, 38, 577), - Trans(61, 23, 38, 577), - Trans(61, 24, 38, 577), - Trans(61, 25, 38, 577), - Trans(61, 26, 38, 577), - Trans(61, 31, 38, 577), - Trans(61, 32, 38, 577), - Trans(61, 33, 38, 577), - Trans(61, 34, 38, 577), - Trans(61, 48, 38, 577), - Trans(61, 52, 38, 577), - Trans(62, 31, 38, 577), - Trans(63, 5, 38, 577), - Trans(63, 44, 38, 577), - Trans(63, 54, 38, 577), - Trans(63, 66, 38, 577), - Trans(63, 70, 38, 577), - Trans(63, 71, 38, 577), - Trans(63, 81, 38, 577), - Trans(63, 100, 38, 577), - Trans(63, 101, 38, 577), - Trans(63, 106, 38, 577), - Trans(63, 114, 38, 577), - Trans(63, 115, 38, 577), - Trans(64, 40, 38, 577), - Trans(65, 5, 38, 577), - Trans(65, 6, 38, 577), - Trans(65, 7, 38, 577), - Trans(65, 8, 38, 577), - Trans(65, 9, 38, 577), - Trans(65, 10, 38, 577), - Trans(65, 11, 38, 577), - Trans(65, 18, 38, 577), - Trans(65, 24, 38, 577), - Trans(65, 25, 38, 577), - Trans(65, 26, 38, 577), - Trans(65, 27, 38, 577), - Trans(65, 39, 38, 577), - Trans(65, 40, 38, 577), - Trans(65, 42, 38, 577), - Trans(65, 44, 38, 577), - Trans(65, 54, 38, 577), - Trans(65, 58, 38, 577), - Trans(65, 71, 38, 577), - Trans(65, 77, 38, 577), - Trans(65, 84, 38, 577), - Trans(65, 87, 38, 577), - Trans(65, 89, 38, 577), - Trans(65, 106, 38, 577), - Trans(65, 114, 38, 577), - Trans(65, 115, 38, 577), - Trans(66, 47, 38, 577), - Trans(67, 5, 38, 577), - Trans(67, 44, 38, 577), - Trans(67, 54, 38, 577), - Trans(67, 66, 38, 577), - Trans(67, 70, 38, 577), - Trans(67, 71, 38, 577), - Trans(67, 81, 38, 577), - Trans(67, 100, 38, 577), - Trans(67, 101, 38, 577), - Trans(67, 106, 38, 577), - Trans(67, 113, 38, 577), - Trans(67, 114, 38, 577), - Trans(67, 115, 38, 577), - Trans(68, 115, 38, 577), + Trans(20, 6, 38, 582), + Trans(20, 7, 38, 582), + Trans(20, 8, 38, 582), + Trans(20, 9, 38, 582), + Trans(20, 10, 38, 582), + Trans(20, 11, 38, 582), + Trans(20, 18, 38, 582), + Trans(20, 24, 38, 582), + Trans(20, 25, 38, 582), + Trans(20, 26, 38, 582), + Trans(20, 27, 38, 582), + Trans(20, 31, 38, 582), + Trans(20, 37, 38, 582), + Trans(20, 39, 38, 582), + Trans(20, 40, 38, 582), + Trans(20, 42, 38, 582), + Trans(20, 44, 38, 582), + Trans(20, 49, 38, 582), + Trans(20, 50, 38, 582), + Trans(20, 51, 38, 582), + Trans(20, 54, 38, 582), + Trans(20, 59, 38, 582), + Trans(20, 60, 38, 582), + Trans(20, 62, 38, 582), + Trans(20, 63, 38, 582), + Trans(20, 66, 38, 582), + Trans(20, 67, 38, 582), + Trans(20, 68, 38, 582), + Trans(20, 71, 38, 582), + Trans(20, 72, 38, 582), + Trans(20, 73, 38, 582), + Trans(20, 75, 38, 582), + Trans(20, 78, 38, 582), + Trans(20, 79, 38, 582), + Trans(20, 82, 38, 582), + Trans(20, 83, 38, 582), + Trans(20, 85, 38, 582), + Trans(20, 86, 38, 582), + Trans(20, 88, 38, 582), + Trans(20, 90, 38, 582), + Trans(20, 102, 38, 582), + Trans(20, 103, 38, 582), + Trans(20, 107, 38, 582), + Trans(20, 108, 38, 582), + Trans(20, 110, 38, 582), + Trans(20, 113, 38, 582), + Trans(20, 114, 38, 582), + Trans(20, 115, 38, 582), + Trans(20, 116, 38, 582), + Trans(20, 117, 38, 582), + Trans(21, 5, 38, 582), + Trans(21, 16, 38, 582), + Trans(21, 17, 38, 582), + Trans(21, 18, 38, 582), + Trans(21, 19, 38, 582), + Trans(21, 20, 38, 582), + Trans(21, 21, 38, 582), + Trans(21, 22, 38, 582), + Trans(21, 23, 38, 582), + Trans(21, 24, 38, 582), + Trans(21, 25, 38, 582), + Trans(21, 26, 38, 582), + Trans(21, 31, 38, 582), + Trans(21, 32, 38, 582), + Trans(21, 33, 38, 582), + Trans(21, 34, 38, 582), + Trans(21, 48, 38, 582), + Trans(21, 52, 38, 582), + Trans(22, 5, 38, 582), + Trans(22, 6, 38, 582), + Trans(22, 7, 38, 582), + Trans(22, 8, 38, 582), + Trans(22, 9, 38, 582), + Trans(22, 10, 38, 582), + Trans(22, 11, 38, 582), + Trans(22, 18, 38, 582), + Trans(22, 24, 38, 582), + Trans(22, 25, 38, 582), + Trans(22, 26, 38, 582), + Trans(22, 27, 38, 582), + Trans(22, 39, 38, 582), + Trans(22, 40, 38, 582), + Trans(22, 42, 38, 582), + Trans(22, 54, 38, 582), + Trans(22, 72, 38, 582), + Trans(22, 78, 38, 582), + Trans(22, 85, 38, 582), + Trans(22, 88, 38, 582), + Trans(22, 90, 38, 582), + Trans(22, 108, 38, 582), + Trans(22, 116, 38, 582), + Trans(22, 117, 38, 582), + Trans(23, 5, 38, 582), + Trans(23, 117, 38, 582), + Trans(24, 5, 38, 582), + Trans(24, 41, 38, 582), + Trans(25, 5, 38, 582), + Trans(25, 6, 38, 582), + Trans(25, 7, 38, 582), + Trans(25, 8, 38, 582), + Trans(25, 9, 38, 582), + Trans(25, 10, 38, 582), + Trans(25, 11, 38, 582), + Trans(25, 18, 38, 582), + Trans(25, 24, 38, 582), + Trans(25, 25, 38, 582), + Trans(25, 26, 38, 582), + Trans(25, 27, 38, 582), + Trans(25, 39, 38, 582), + Trans(25, 40, 38, 582), + Trans(25, 42, 38, 582), + Trans(25, 54, 38, 582), + Trans(25, 59, 38, 582), + Trans(25, 72, 38, 582), + Trans(25, 78, 38, 582), + Trans(25, 85, 38, 582), + Trans(25, 88, 38, 582), + Trans(25, 90, 38, 582), + Trans(25, 108, 38, 582), + Trans(25, 116, 38, 582), + Trans(25, 117, 38, 582), + Trans(26, 5, 38, 582), + Trans(26, 6, 38, 582), + Trans(26, 7, 38, 582), + Trans(26, 8, 38, 582), + Trans(26, 9, 38, 582), + Trans(26, 10, 38, 582), + Trans(26, 11, 38, 582), + Trans(26, 18, 38, 582), + Trans(26, 24, 38, 582), + Trans(26, 25, 38, 582), + Trans(26, 26, 38, 582), + Trans(26, 27, 38, 582), + Trans(26, 31, 38, 582), + Trans(26, 37, 38, 582), + Trans(26, 39, 38, 582), + Trans(26, 40, 38, 582), + Trans(26, 42, 38, 582), + Trans(26, 44, 38, 582), + Trans(26, 49, 38, 582), + Trans(26, 50, 38, 582), + Trans(26, 51, 38, 582), + Trans(26, 54, 38, 582), + Trans(26, 62, 38, 582), + Trans(26, 63, 38, 582), + Trans(26, 66, 38, 582), + Trans(26, 67, 38, 582), + Trans(26, 68, 38, 582), + Trans(26, 72, 38, 582), + Trans(26, 73, 38, 582), + Trans(26, 75, 38, 582), + Trans(26, 78, 38, 582), + Trans(26, 79, 38, 582), + Trans(26, 82, 38, 582), + Trans(26, 83, 38, 582), + Trans(26, 85, 38, 582), + Trans(26, 86, 38, 582), + Trans(26, 88, 38, 582), + Trans(26, 90, 38, 582), + Trans(26, 107, 38, 582), + Trans(26, 108, 38, 582), + Trans(26, 110, 38, 582), + Trans(26, 113, 38, 582), + Trans(26, 114, 38, 582), + Trans(26, 115, 38, 582), + Trans(26, 116, 38, 582), + Trans(26, 117, 38, 582), + Trans(27, 0, 38, 582), + Trans(27, 5, 38, 582), + Trans(27, 6, 38, 582), + Trans(27, 7, 38, 582), + Trans(27, 8, 38, 582), + Trans(27, 9, 38, 582), + Trans(27, 10, 38, 582), + Trans(27, 11, 38, 582), + Trans(27, 18, 38, 582), + Trans(27, 24, 38, 582), + Trans(27, 25, 38, 582), + Trans(27, 26, 38, 582), + Trans(27, 27, 38, 582), + Trans(27, 31, 38, 582), + Trans(27, 37, 38, 582), + Trans(27, 39, 38, 582), + Trans(27, 40, 38, 582), + Trans(27, 42, 38, 582), + Trans(27, 44, 38, 582), + Trans(27, 49, 38, 582), + Trans(27, 50, 38, 582), + Trans(27, 51, 38, 582), + Trans(27, 54, 38, 582), + Trans(27, 59, 38, 582), + Trans(27, 60, 38, 582), + Trans(27, 61, 38, 582), + Trans(27, 62, 38, 582), + Trans(27, 63, 38, 582), + Trans(27, 66, 38, 582), + Trans(27, 67, 38, 582), + Trans(27, 68, 38, 582), + Trans(27, 71, 38, 582), + Trans(27, 72, 38, 582), + Trans(27, 73, 38, 582), + Trans(27, 74, 38, 582), + Trans(27, 75, 38, 582), + Trans(27, 78, 38, 582), + Trans(27, 79, 38, 582), + Trans(27, 80, 38, 582), + Trans(27, 82, 38, 582), + Trans(27, 83, 38, 582), + Trans(27, 85, 38, 582), + Trans(27, 86, 38, 582), + Trans(27, 87, 38, 582), + Trans(27, 88, 38, 582), + Trans(27, 90, 38, 582), + Trans(27, 91, 38, 582), + Trans(27, 93, 38, 582), + Trans(27, 94, 38, 582), + Trans(27, 102, 38, 582), + Trans(27, 103, 38, 582), + Trans(27, 107, 38, 582), + Trans(27, 108, 38, 582), + Trans(27, 110, 38, 582), + Trans(27, 113, 38, 582), + Trans(27, 114, 38, 582), + Trans(27, 115, 38, 582), + Trans(27, 116, 38, 582), + Trans(27, 117, 38, 582), + Trans(28, 5, 38, 582), + Trans(28, 40, 38, 582), + Trans(29, 5, 38, 582), + Trans(29, 40, 38, 582), + Trans(29, 42, 38, 582), + Trans(30, 5, 38, 582), + Trans(30, 31, 38, 582), + Trans(31, 5, 38, 582), + Trans(31, 40, 38, 582), + Trans(31, 72, 38, 582), + Trans(32, 5, 38, 582), + Trans(32, 48, 38, 582), + Trans(32, 116, 38, 582), + Trans(32, 117, 38, 582), + Trans(33, 5, 38, 582), + Trans(33, 116, 38, 582), + Trans(33, 117, 38, 582), + Trans(34, 5, 38, 582), + Trans(34, 47, 38, 582), + Trans(35, 5, 38, 582), + Trans(35, 42, 38, 582), + Trans(36, 5, 38, 582), + Trans(36, 15, 38, 582), + Trans(36, 16, 38, 582), + Trans(36, 17, 38, 582), + Trans(36, 18, 38, 582), + Trans(36, 19, 38, 582), + Trans(36, 20, 38, 582), + Trans(36, 21, 38, 582), + Trans(36, 22, 38, 582), + Trans(36, 23, 38, 582), + Trans(36, 24, 38, 582), + Trans(36, 25, 38, 582), + Trans(36, 26, 38, 582), + Trans(36, 30, 38, 582), + Trans(36, 31, 38, 582), + Trans(36, 32, 38, 582), + Trans(36, 33, 38, 582), + Trans(36, 34, 38, 582), + Trans(36, 35, 38, 582), + Trans(36, 36, 38, 582), + Trans(36, 41, 38, 582), + Trans(36, 42, 38, 582), + Trans(36, 48, 38, 582), + Trans(36, 52, 38, 582), + Trans(37, 5, 38, 582), + Trans(37, 15, 38, 582), + Trans(37, 16, 38, 582), + Trans(37, 17, 38, 582), + Trans(37, 18, 38, 582), + Trans(37, 19, 38, 582), + Trans(37, 20, 38, 582), + Trans(37, 21, 38, 582), + Trans(37, 22, 38, 582), + Trans(37, 23, 38, 582), + Trans(37, 24, 38, 582), + Trans(37, 25, 38, 582), + Trans(37, 26, 38, 582), + Trans(37, 29, 38, 582), + Trans(37, 30, 38, 582), + Trans(37, 31, 38, 582), + Trans(37, 32, 38, 582), + Trans(37, 33, 38, 582), + Trans(37, 34, 38, 582), + Trans(37, 35, 38, 582), + Trans(37, 36, 38, 582), + Trans(37, 41, 38, 582), + Trans(37, 42, 38, 582), + Trans(37, 48, 38, 582), + Trans(37, 52, 38, 582), + Trans(39, 6, 38, 582), + Trans(39, 7, 38, 582), + Trans(39, 8, 38, 582), + Trans(39, 9, 38, 582), + Trans(39, 10, 38, 582), + Trans(39, 11, 38, 582), + Trans(39, 18, 38, 582), + Trans(39, 24, 38, 582), + Trans(39, 25, 38, 582), + Trans(39, 26, 38, 582), + Trans(39, 27, 38, 582), + Trans(39, 39, 38, 582), + Trans(39, 40, 38, 582), + Trans(39, 42, 38, 582), + Trans(39, 54, 38, 582), + Trans(39, 72, 38, 582), + Trans(39, 78, 38, 582), + Trans(39, 85, 38, 582), + Trans(39, 88, 38, 582), + Trans(39, 90, 38, 582), + Trans(39, 108, 38, 582), + Trans(39, 116, 38, 582), + Trans(39, 117, 38, 582), + Trans(40, 5, 38, 582), + Trans(40, 16, 38, 582), + Trans(40, 17, 38, 582), + Trans(40, 18, 38, 582), + Trans(40, 19, 38, 582), + Trans(40, 20, 38, 582), + Trans(40, 21, 38, 582), + Trans(40, 22, 38, 582), + Trans(40, 23, 38, 582), + Trans(40, 24, 38, 582), + Trans(40, 25, 38, 582), + Trans(40, 26, 38, 582), + Trans(40, 30, 38, 582), + Trans(40, 31, 38, 582), + Trans(40, 32, 38, 582), + Trans(40, 33, 38, 582), + Trans(40, 34, 38, 582), + Trans(40, 35, 38, 582), + Trans(40, 41, 38, 582), + Trans(40, 42, 38, 582), + Trans(40, 48, 38, 582), + Trans(40, 52, 38, 582), + Trans(41, 5, 38, 582), + Trans(41, 16, 38, 582), + Trans(41, 17, 38, 582), + Trans(41, 18, 38, 582), + Trans(41, 19, 38, 582), + Trans(41, 20, 38, 582), + Trans(41, 21, 38, 582), + Trans(41, 22, 38, 582), + Trans(41, 23, 38, 582), + Trans(41, 24, 38, 582), + Trans(41, 25, 38, 582), + Trans(41, 26, 38, 582), + Trans(41, 29, 38, 582), + Trans(41, 30, 38, 582), + Trans(41, 31, 38, 582), + Trans(41, 32, 38, 582), + Trans(41, 33, 38, 582), + Trans(41, 34, 38, 582), + Trans(41, 35, 38, 582), + Trans(41, 41, 38, 582), + Trans(41, 42, 38, 582), + Trans(41, 48, 38, 582), + Trans(41, 52, 38, 582), + Trans(42, 6, 38, 582), + Trans(42, 7, 38, 582), + Trans(42, 8, 38, 582), + Trans(42, 9, 38, 582), + Trans(42, 10, 38, 582), + Trans(42, 11, 38, 582), + Trans(42, 18, 38, 582), + Trans(42, 24, 38, 582), + Trans(42, 25, 38, 582), + Trans(42, 26, 38, 582), + Trans(42, 27, 38, 582), + Trans(42, 39, 38, 582), + Trans(42, 40, 38, 582), + Trans(42, 42, 38, 582), + Trans(42, 54, 38, 582), + Trans(42, 59, 38, 582), + Trans(42, 72, 38, 582), + Trans(42, 78, 38, 582), + Trans(42, 85, 38, 582), + Trans(42, 88, 38, 582), + Trans(42, 90, 38, 582), + Trans(42, 108, 38, 582), + Trans(42, 116, 38, 582), + Trans(42, 117, 38, 582), + Trans(43, 5, 38, 582), + Trans(43, 16, 38, 582), + Trans(43, 17, 38, 582), + Trans(43, 18, 38, 582), + Trans(43, 19, 38, 582), + Trans(43, 20, 38, 582), + Trans(43, 21, 38, 582), + Trans(43, 22, 38, 582), + Trans(43, 23, 38, 582), + Trans(43, 24, 38, 582), + Trans(43, 25, 38, 582), + Trans(43, 26, 38, 582), + Trans(43, 32, 38, 582), + Trans(43, 44, 38, 582), + Trans(43, 48, 38, 582), + Trans(43, 52, 38, 582), + Trans(43, 96, 38, 582), + Trans(44, 5, 38, 582), + Trans(44, 16, 38, 582), + Trans(44, 17, 38, 582), + Trans(44, 18, 38, 582), + Trans(44, 19, 38, 582), + Trans(44, 20, 38, 582), + Trans(44, 21, 38, 582), + Trans(44, 22, 38, 582), + Trans(44, 23, 38, 582), + Trans(44, 24, 38, 582), + Trans(44, 25, 38, 582), + Trans(44, 26, 38, 582), + Trans(44, 30, 38, 582), + Trans(44, 32, 38, 582), + Trans(44, 35, 38, 582), + Trans(44, 41, 38, 582), + Trans(44, 42, 38, 582), + Trans(44, 44, 38, 582), + Trans(44, 48, 38, 582), + Trans(44, 52, 38, 582), + Trans(44, 96, 38, 582), + Trans(45, 5, 38, 582), + Trans(45, 16, 38, 582), + Trans(45, 17, 38, 582), + Trans(45, 18, 38, 582), + Trans(45, 19, 38, 582), + Trans(45, 20, 38, 582), + Trans(45, 21, 38, 582), + Trans(45, 22, 38, 582), + Trans(45, 23, 38, 582), + Trans(45, 24, 38, 582), + Trans(45, 25, 38, 582), + Trans(45, 26, 38, 582), + Trans(45, 29, 38, 582), + Trans(45, 30, 38, 582), + Trans(45, 32, 38, 582), + Trans(45, 35, 38, 582), + Trans(45, 41, 38, 582), + Trans(45, 42, 38, 582), + Trans(45, 44, 38, 582), + Trans(45, 48, 38, 582), + Trans(45, 52, 38, 582), + Trans(45, 96, 38, 582), + Trans(46, 5, 38, 582), + Trans(46, 16, 38, 582), + Trans(46, 17, 38, 582), + Trans(46, 18, 38, 582), + Trans(46, 19, 38, 582), + Trans(46, 20, 38, 582), + Trans(46, 21, 38, 582), + Trans(46, 22, 38, 582), + Trans(46, 23, 38, 582), + Trans(46, 24, 38, 582), + Trans(46, 25, 38, 582), + Trans(46, 26, 38, 582), + Trans(46, 46, 38, 582), + Trans(46, 48, 38, 582), + Trans(46, 52, 38, 582), + Trans(47, 5, 38, 582), + Trans(47, 16, 38, 582), + Trans(47, 17, 38, 582), + Trans(47, 18, 38, 582), + Trans(47, 19, 38, 582), + Trans(47, 20, 38, 582), + Trans(47, 21, 38, 582), + Trans(47, 22, 38, 582), + Trans(47, 23, 38, 582), + Trans(47, 24, 38, 582), + Trans(47, 25, 38, 582), + Trans(47, 26, 38, 582), + Trans(47, 30, 38, 582), + Trans(47, 35, 38, 582), + Trans(47, 41, 38, 582), + Trans(47, 42, 38, 582), + Trans(47, 46, 38, 582), + Trans(47, 48, 38, 582), + Trans(47, 52, 38, 582), + Trans(48, 5, 38, 582), + Trans(48, 16, 38, 582), + Trans(48, 17, 38, 582), + Trans(48, 18, 38, 582), + Trans(48, 19, 38, 582), + Trans(48, 20, 38, 582), + Trans(48, 21, 38, 582), + Trans(48, 22, 38, 582), + Trans(48, 23, 38, 582), + Trans(48, 24, 38, 582), + Trans(48, 25, 38, 582), + Trans(48, 26, 38, 582), + Trans(48, 29, 38, 582), + Trans(48, 30, 38, 582), + Trans(48, 35, 38, 582), + Trans(48, 41, 38, 582), + Trans(48, 42, 38, 582), + Trans(48, 46, 38, 582), + Trans(48, 48, 38, 582), + Trans(48, 52, 38, 582), + Trans(49, 5, 38, 582), + Trans(49, 16, 38, 582), + Trans(49, 17, 38, 582), + Trans(49, 18, 38, 582), + Trans(49, 19, 38, 582), + Trans(49, 20, 38, 582), + Trans(49, 21, 38, 582), + Trans(49, 22, 38, 582), + Trans(49, 23, 38, 582), + Trans(49, 24, 38, 582), + Trans(49, 25, 38, 582), + Trans(49, 26, 38, 582), + Trans(49, 40, 38, 582), + Trans(49, 48, 38, 582), + Trans(49, 52, 38, 582), + Trans(50, 5, 38, 582), + Trans(50, 16, 38, 582), + Trans(50, 17, 38, 582), + Trans(50, 18, 38, 582), + Trans(50, 19, 38, 582), + Trans(50, 20, 38, 582), + Trans(50, 21, 38, 582), + Trans(50, 22, 38, 582), + Trans(50, 23, 38, 582), + Trans(50, 24, 38, 582), + Trans(50, 25, 38, 582), + Trans(50, 26, 38, 582), + Trans(50, 30, 38, 582), + Trans(50, 35, 38, 582), + Trans(50, 40, 38, 582), + Trans(50, 41, 38, 582), + Trans(50, 42, 38, 582), + Trans(50, 48, 38, 582), + Trans(50, 52, 38, 582), + Trans(51, 5, 38, 582), + Trans(51, 16, 38, 582), + Trans(51, 17, 38, 582), + Trans(51, 18, 38, 582), + Trans(51, 19, 38, 582), + Trans(51, 20, 38, 582), + Trans(51, 21, 38, 582), + Trans(51, 22, 38, 582), + Trans(51, 23, 38, 582), + Trans(51, 24, 38, 582), + Trans(51, 25, 38, 582), + Trans(51, 26, 38, 582), + Trans(51, 29, 38, 582), + Trans(51, 30, 38, 582), + Trans(51, 35, 38, 582), + Trans(51, 40, 38, 582), + Trans(51, 41, 38, 582), + Trans(51, 42, 38, 582), + Trans(51, 48, 38, 582), + Trans(51, 52, 38, 582), + Trans(52, 5, 38, 582), + Trans(52, 16, 38, 582), + Trans(52, 17, 38, 582), + Trans(52, 18, 38, 582), + Trans(52, 19, 38, 582), + Trans(52, 20, 38, 582), + Trans(52, 21, 38, 582), + Trans(52, 22, 38, 582), + Trans(52, 23, 38, 582), + Trans(52, 24, 38, 582), + Trans(52, 25, 38, 582), + Trans(52, 26, 38, 582), + Trans(52, 47, 38, 582), + Trans(52, 48, 38, 582), + Trans(52, 52, 38, 582), + Trans(53, 5, 38, 582), + Trans(53, 16, 38, 582), + Trans(53, 17, 38, 582), + Trans(53, 18, 38, 582), + Trans(53, 19, 38, 582), + Trans(53, 20, 38, 582), + Trans(53, 21, 38, 582), + Trans(53, 22, 38, 582), + Trans(53, 23, 38, 582), + Trans(53, 24, 38, 582), + Trans(53, 25, 38, 582), + Trans(53, 26, 38, 582), + Trans(53, 30, 38, 582), + Trans(53, 35, 38, 582), + Trans(53, 41, 38, 582), + Trans(53, 42, 38, 582), + Trans(53, 47, 38, 582), + Trans(53, 48, 38, 582), + Trans(53, 52, 38, 582), + Trans(54, 5, 38, 582), + Trans(54, 16, 38, 582), + Trans(54, 17, 38, 582), + Trans(54, 18, 38, 582), + Trans(54, 19, 38, 582), + Trans(54, 20, 38, 582), + Trans(54, 21, 38, 582), + Trans(54, 22, 38, 582), + Trans(54, 23, 38, 582), + Trans(54, 24, 38, 582), + Trans(54, 25, 38, 582), + Trans(54, 26, 38, 582), + Trans(54, 29, 38, 582), + Trans(54, 30, 38, 582), + Trans(54, 35, 38, 582), + Trans(54, 41, 38, 582), + Trans(54, 42, 38, 582), + Trans(54, 47, 38, 582), + Trans(54, 48, 38, 582), + Trans(54, 52, 38, 582), + Trans(55, 15, 38, 582), + Trans(55, 16, 38, 582), + Trans(55, 17, 38, 582), + Trans(55, 18, 38, 582), + Trans(55, 19, 38, 582), + Trans(55, 20, 38, 582), + Trans(55, 21, 38, 582), + Trans(55, 22, 38, 582), + Trans(55, 23, 38, 582), + Trans(55, 24, 38, 582), + Trans(55, 25, 38, 582), + Trans(55, 26, 38, 582), + Trans(55, 30, 38, 582), + Trans(55, 31, 38, 582), + Trans(55, 32, 38, 582), + Trans(55, 33, 38, 582), + Trans(55, 34, 38, 582), + Trans(55, 35, 38, 582), + Trans(55, 36, 38, 582), + Trans(55, 41, 38, 582), + Trans(55, 42, 38, 582), + Trans(55, 48, 38, 582), + Trans(55, 52, 38, 582), + Trans(56, 5, 38, 582), + Trans(56, 40, 38, 582), + Trans(56, 54, 38, 582), + Trans(56, 67, 38, 582), + Trans(56, 71, 38, 582), + Trans(56, 72, 38, 582), + Trans(56, 82, 38, 582), + Trans(56, 102, 38, 582), + Trans(56, 103, 38, 582), + Trans(56, 108, 38, 582), + Trans(56, 116, 38, 582), + Trans(56, 117, 38, 582), + Trans(57, 5, 38, 582), + Trans(57, 6, 38, 582), + Trans(57, 7, 38, 582), + Trans(57, 8, 38, 582), + Trans(57, 9, 38, 582), + Trans(57, 10, 38, 582), + Trans(57, 11, 38, 582), + Trans(57, 18, 38, 582), + Trans(57, 24, 38, 582), + Trans(57, 25, 38, 582), + Trans(57, 26, 38, 582), + Trans(57, 27, 38, 582), + Trans(57, 39, 38, 582), + Trans(57, 40, 38, 582), + Trans(57, 42, 38, 582), + Trans(57, 46, 38, 582), + Trans(57, 54, 38, 582), + Trans(57, 72, 38, 582), + Trans(57, 78, 38, 582), + Trans(57, 85, 38, 582), + Trans(57, 88, 38, 582), + Trans(57, 90, 38, 582), + Trans(57, 108, 38, 582), + Trans(57, 116, 38, 582), + Trans(57, 117, 38, 582), + Trans(58, 5, 38, 582), + Trans(58, 55, 38, 582), + Trans(58, 56, 38, 582), + Trans(58, 57, 38, 582), + Trans(58, 64, 38, 582), + Trans(58, 65, 38, 582), + Trans(58, 69, 38, 582), + Trans(58, 70, 38, 582), + Trans(58, 97, 38, 582), + Trans(58, 98, 38, 582), + Trans(58, 99, 38, 582), + Trans(58, 100, 38, 582), + Trans(58, 101, 38, 582), + Trans(58, 111, 38, 582), + Trans(58, 112, 38, 582), + Trans(58, 116, 38, 582), + Trans(58, 117, 38, 582), + Trans(59, 15, 38, 582), + Trans(59, 16, 38, 582), + Trans(59, 17, 38, 582), + Trans(59, 18, 38, 582), + Trans(59, 19, 38, 582), + Trans(59, 20, 38, 582), + Trans(59, 21, 38, 582), + Trans(59, 22, 38, 582), + Trans(59, 23, 38, 582), + Trans(59, 24, 38, 582), + Trans(59, 25, 38, 582), + Trans(59, 26, 38, 582), + Trans(59, 29, 38, 582), + Trans(59, 30, 38, 582), + Trans(59, 31, 38, 582), + Trans(59, 32, 38, 582), + Trans(59, 33, 38, 582), + Trans(59, 34, 38, 582), + Trans(59, 35, 38, 582), + Trans(59, 36, 38, 582), + Trans(59, 41, 38, 582), + Trans(59, 42, 38, 582), + Trans(59, 48, 38, 582), + Trans(59, 52, 38, 582), + Trans(60, 5, 38, 582), + Trans(60, 7, 38, 582), + Trans(60, 8, 38, 582), + Trans(60, 9, 38, 582), + Trans(60, 10, 38, 582), + Trans(60, 11, 38, 582), + Trans(60, 43, 38, 582), + Trans(60, 116, 38, 582), + Trans(60, 117, 38, 582), + Trans(61, 16, 38, 582), + Trans(61, 17, 38, 582), + Trans(61, 18, 38, 582), + Trans(61, 19, 38, 582), + Trans(61, 20, 38, 582), + Trans(61, 21, 38, 582), + Trans(61, 22, 38, 582), + Trans(61, 23, 38, 582), + Trans(61, 24, 38, 582), + Trans(61, 25, 38, 582), + Trans(61, 26, 38, 582), + Trans(61, 31, 38, 582), + Trans(61, 32, 38, 582), + Trans(61, 33, 38, 582), + Trans(61, 34, 38, 582), + Trans(61, 48, 38, 582), + Trans(61, 52, 38, 582), + Trans(62, 31, 38, 582), + Trans(63, 5, 38, 582), + Trans(63, 44, 38, 582), + Trans(63, 54, 38, 582), + Trans(63, 67, 38, 582), + Trans(63, 71, 38, 582), + Trans(63, 72, 38, 582), + Trans(63, 82, 38, 582), + Trans(63, 102, 38, 582), + Trans(63, 103, 38, 582), + Trans(63, 108, 38, 582), + Trans(63, 116, 38, 582), + Trans(63, 117, 38, 582), + Trans(64, 40, 38, 582), + Trans(65, 5, 38, 582), + Trans(65, 6, 38, 582), + Trans(65, 7, 38, 582), + Trans(65, 8, 38, 582), + Trans(65, 9, 38, 582), + Trans(65, 10, 38, 582), + Trans(65, 11, 38, 582), + Trans(65, 18, 38, 582), + Trans(65, 24, 38, 582), + Trans(65, 25, 38, 582), + Trans(65, 26, 38, 582), + Trans(65, 27, 38, 582), + Trans(65, 39, 38, 582), + Trans(65, 40, 38, 582), + Trans(65, 42, 38, 582), + Trans(65, 44, 38, 582), + Trans(65, 54, 38, 582), + Trans(65, 59, 38, 582), + Trans(65, 72, 38, 582), + Trans(65, 78, 38, 582), + Trans(65, 85, 38, 582), + Trans(65, 88, 38, 582), + Trans(65, 90, 38, 582), + Trans(65, 108, 38, 582), + Trans(65, 116, 38, 582), + Trans(65, 117, 38, 582), + Trans(66, 47, 38, 582), + Trans(67, 5, 38, 582), + Trans(67, 44, 38, 582), + Trans(67, 54, 38, 582), + Trans(67, 67, 38, 582), + Trans(67, 71, 38, 582), + Trans(67, 72, 38, 582), + Trans(67, 82, 38, 582), + Trans(67, 102, 38, 582), + Trans(67, 103, 38, 582), + Trans(67, 108, 38, 582), + Trans(67, 115, 38, 582), + Trans(67, 116, 38, 582), + Trans(67, 117, 38, 582), + Trans(68, 117, 38, 582), ], k: 3, }, - /* 262 - "IfResetStatementList0List" */ + /* 266 - "IfResetStatementList0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 576), - Trans(0, 54, 1, 575), - Trans(0, 66, 1, 575), - Trans(0, 70, 1, 575), - Trans(0, 71, 1, 575), - Trans(0, 81, 1, 575), - Trans(0, 100, 1, 575), - Trans(0, 101, 1, 575), - Trans(0, 106, 1, 575), - Trans(0, 114, 1, 575), - Trans(0, 115, 1, 575), + Trans(0, 44, 2, 581), + Trans(0, 54, 1, 580), + Trans(0, 67, 1, 580), + Trans(0, 71, 1, 580), + Trans(0, 72, 1, 580), + Trans(0, 82, 1, 580), + Trans(0, 102, 1, 580), + Trans(0, 103, 1, 580), + Trans(0, 108, 1, 580), + Trans(0, 116, 1, 580), + Trans(0, 117, 1, 580), ], k: 1, }, - /* 263 - "IfResetStatementOpt" */ + /* 267 - "IfResetStatementOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 2, 583), - Trans(0, 7, 2, 583), - Trans(0, 8, 2, 583), - Trans(0, 9, 2, 583), - Trans(0, 10, 2, 583), - Trans(0, 11, 2, 583), - Trans(0, 18, 2, 583), - Trans(0, 24, 2, 583), - Trans(0, 25, 2, 583), - Trans(0, 26, 2, 583), - Trans(0, 27, 2, 583), - Trans(0, 39, 2, 583), - Trans(0, 40, 2, 583), - Trans(0, 42, 2, 583), - Trans(0, 44, 2, 583), - Trans(0, 54, 2, 583), - Trans(0, 58, 2, 583), - Trans(0, 59, 1, 580), - Trans(0, 66, 2, 583), - Trans(0, 70, 2, 583), - Trans(0, 71, 2, 583), - Trans(0, 77, 2, 583), - Trans(0, 81, 2, 583), - Trans(0, 84, 2, 583), - Trans(0, 87, 2, 583), - Trans(0, 89, 2, 583), - Trans(0, 100, 2, 583), - Trans(0, 101, 2, 583), - Trans(0, 106, 2, 583), - Trans(0, 113, 2, 583), - Trans(0, 114, 2, 583), - Trans(0, 115, 2, 583), + Trans(0, 6, 2, 588), + Trans(0, 7, 2, 588), + Trans(0, 8, 2, 588), + Trans(0, 9, 2, 588), + Trans(0, 10, 2, 588), + Trans(0, 11, 2, 588), + Trans(0, 18, 2, 588), + Trans(0, 24, 2, 588), + Trans(0, 25, 2, 588), + Trans(0, 26, 2, 588), + Trans(0, 27, 2, 588), + Trans(0, 39, 2, 588), + Trans(0, 40, 2, 588), + Trans(0, 42, 2, 588), + Trans(0, 44, 2, 588), + Trans(0, 54, 2, 588), + Trans(0, 59, 2, 588), + Trans(0, 60, 1, 585), + Trans(0, 67, 2, 588), + Trans(0, 71, 2, 588), + Trans(0, 72, 2, 588), + Trans(0, 78, 2, 588), + Trans(0, 82, 2, 588), + Trans(0, 85, 2, 588), + Trans(0, 88, 2, 588), + Trans(0, 90, 2, 588), + Trans(0, 102, 2, 588), + Trans(0, 103, 2, 588), + Trans(0, 108, 2, 588), + Trans(0, 115, 2, 588), + Trans(0, 116, 2, 588), + Trans(0, 117, 2, 588), ], k: 1, }, - /* 264 - "IfResetStatementOptList" */ + /* 268 - "IfResetStatementOptList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 582), - Trans(0, 54, 1, 581), - Trans(0, 66, 1, 581), - Trans(0, 70, 1, 581), - Trans(0, 71, 1, 581), - Trans(0, 81, 1, 581), - Trans(0, 100, 1, 581), - Trans(0, 101, 1, 581), - Trans(0, 106, 1, 581), - Trans(0, 114, 1, 581), - Trans(0, 115, 1, 581), + Trans(0, 44, 2, 587), + Trans(0, 54, 1, 586), + Trans(0, 67, 1, 586), + Trans(0, 71, 1, 586), + Trans(0, 72, 1, 586), + Trans(0, 82, 1, 586), + Trans(0, 102, 1, 586), + Trans(0, 103, 1, 586), + Trans(0, 108, 1, 586), + Trans(0, 116, 1, 586), + Trans(0, 117, 1, 586), ], k: 1, }, - /* 265 - "IfResetTerm" */ + /* 269 - "IfResetTerm" */ LookaheadDFA { - prod0: 65, + prod0: 66, transitions: &[], k: 0, }, - /* 266 - "IfResetToken" */ + /* 270 - "IfResetToken" */ LookaheadDFA { - prod0: 180, + prod0: 183, transitions: &[], k: 0, }, - /* 267 - "IfStatement" */ + /* 271 - "IfStatement" */ LookaheadDFA { - prod0: 562, + prod0: 567, transitions: &[], k: 0, }, - /* 268 - "IfStatementList" */ + /* 272 - "IfStatementList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 568), - Trans(0, 54, 1, 567), - Trans(0, 66, 1, 567), - Trans(0, 70, 1, 567), - Trans(0, 71, 1, 567), - Trans(0, 81, 1, 567), - Trans(0, 100, 1, 567), - Trans(0, 101, 1, 567), - Trans(0, 106, 1, 567), - Trans(0, 114, 1, 567), - Trans(0, 115, 1, 567), + Trans(0, 44, 2, 573), + Trans(0, 54, 1, 572), + Trans(0, 67, 1, 572), + Trans(0, 71, 1, 572), + Trans(0, 72, 1, 572), + Trans(0, 82, 1, 572), + Trans(0, 102, 1, 572), + Trans(0, 103, 1, 572), + Trans(0, 108, 1, 572), + Trans(0, 116, 1, 572), + Trans(0, 117, 1, 572), ], k: 1, }, - /* 269 - "IfStatementList0" */ + /* 273 - "IfStatementList0" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -7078,51 +7145,51 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 42, 9, -1), Trans(0, 44, 10, -1), Trans(0, 54, 11, -1), - Trans(0, 58, 12, -1), - Trans(0, 59, 1, -1), - Trans(0, 66, 13, -1), - Trans(0, 70, 14, -1), - Trans(0, 71, 11, -1), - Trans(0, 77, 11, -1), - Trans(0, 81, 13, -1), - Trans(0, 84, 5, -1), - Trans(0, 87, 5, -1), - Trans(0, 89, 11, -1), - Trans(0, 100, 15, -1), - Trans(0, 101, 16, -1), - Trans(0, 106, 17, -1), - Trans(0, 113, 13, -1), - Trans(0, 114, 18, -1), - Trans(0, 115, 19, -1), + Trans(0, 59, 12, -1), + Trans(0, 60, 1, -1), + Trans(0, 67, 13, -1), + Trans(0, 71, 14, -1), + Trans(0, 72, 11, -1), + Trans(0, 78, 11, -1), + Trans(0, 82, 13, -1), + Trans(0, 85, 5, -1), + Trans(0, 88, 5, -1), + Trans(0, 90, 11, -1), + Trans(0, 102, 15, -1), + Trans(0, 103, 16, -1), + Trans(0, 108, 17, -1), + Trans(0, 115, 13, -1), + Trans(0, 116, 18, -1), + Trans(0, 117, 19, -1), Trans(1, 5, 4, -1), Trans(1, 40, 63, -1), - Trans(1, 71, 2, -1), - Trans(2, 5, 3, 563), - Trans(2, 6, 3, 563), - Trans(2, 7, 3, 563), - Trans(2, 8, 3, 563), - Trans(2, 9, 3, 563), - Trans(2, 10, 3, 563), - Trans(2, 11, 3, 563), - Trans(2, 18, 3, 563), - Trans(2, 24, 3, 563), - Trans(2, 25, 3, 563), - Trans(2, 26, 3, 563), - Trans(2, 27, 3, 563), - Trans(2, 39, 3, 563), - Trans(2, 40, 3, 563), - Trans(2, 42, 3, 563), - Trans(2, 54, 3, 563), - Trans(2, 71, 3, 563), - Trans(2, 77, 3, 563), - Trans(2, 84, 3, 563), - Trans(2, 87, 3, 563), - Trans(2, 89, 3, 563), - Trans(2, 106, 3, 563), - Trans(2, 114, 3, 563), - Trans(2, 115, 3, 563), - Trans(4, 40, 38, 566), - Trans(4, 71, 3, 563), + Trans(1, 72, 2, -1), + Trans(2, 5, 3, 568), + Trans(2, 6, 3, 568), + Trans(2, 7, 3, 568), + Trans(2, 8, 3, 568), + Trans(2, 9, 3, 568), + Trans(2, 10, 3, 568), + Trans(2, 11, 3, 568), + Trans(2, 18, 3, 568), + Trans(2, 24, 3, 568), + Trans(2, 25, 3, 568), + Trans(2, 26, 3, 568), + Trans(2, 27, 3, 568), + Trans(2, 39, 3, 568), + Trans(2, 40, 3, 568), + Trans(2, 42, 3, 568), + Trans(2, 54, 3, 568), + Trans(2, 72, 3, 568), + Trans(2, 78, 3, 568), + Trans(2, 85, 3, 568), + Trans(2, 88, 3, 568), + Trans(2, 90, 3, 568), + Trans(2, 108, 3, 568), + Trans(2, 116, 3, 568), + Trans(2, 117, 3, 568), + Trans(4, 40, 38, 571), + Trans(4, 72, 3, 568), Trans(5, 5, 61, -1), Trans(5, 16, 22, -1), Trans(5, 17, 22, -1), @@ -7157,14 +7224,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(6, 40, 22, -1), Trans(6, 42, 22, -1), Trans(6, 54, 22, -1), - Trans(6, 71, 22, -1), - Trans(6, 77, 22, -1), - Trans(6, 84, 21, -1), - Trans(6, 87, 21, -1), - Trans(6, 89, 22, -1), - Trans(6, 106, 28, -1), - Trans(6, 114, 40, -1), - Trans(6, 115, 41, -1), + Trans(6, 72, 22, -1), + Trans(6, 78, 22, -1), + Trans(6, 85, 21, -1), + Trans(6, 88, 21, -1), + Trans(6, 90, 22, -1), + Trans(6, 108, 28, -1), + Trans(6, 116, 40, -1), + Trans(6, 117, 41, -1), Trans(7, 5, 42, -1), Trans(7, 6, 43, -1), Trans(7, 7, 43, -1), @@ -7181,15 +7248,15 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(7, 40, 22, -1), Trans(7, 42, 22, -1), Trans(7, 54, 22, -1), - Trans(7, 58, 30, -1), - Trans(7, 71, 22, -1), - Trans(7, 77, 22, -1), - Trans(7, 84, 43, -1), - Trans(7, 87, 43, -1), - Trans(7, 89, 22, -1), - Trans(7, 106, 28, -1), - Trans(7, 114, 44, -1), - Trans(7, 115, 45, -1), + Trans(7, 59, 30, -1), + Trans(7, 72, 22, -1), + Trans(7, 78, 22, -1), + Trans(7, 85, 43, -1), + Trans(7, 88, 43, -1), + Trans(7, 90, 22, -1), + Trans(7, 108, 28, -1), + Trans(7, 116, 44, -1), + Trans(7, 117, 45, -1), Trans(8, 5, 39, -1), Trans(8, 6, 43, -1), Trans(8, 7, 43, -1), @@ -7206,14 +7273,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(8, 40, 22, -1), Trans(8, 42, 22, -1), Trans(8, 54, 22, -1), - Trans(8, 71, 22, -1), - Trans(8, 77, 22, -1), - Trans(8, 84, 43, -1), - Trans(8, 87, 43, -1), - Trans(8, 89, 22, -1), - Trans(8, 106, 28, -1), - Trans(8, 114, 44, -1), - Trans(8, 115, 45, -1), + Trans(8, 72, 22, -1), + Trans(8, 78, 22, -1), + Trans(8, 85, 43, -1), + Trans(8, 88, 43, -1), + Trans(8, 90, 22, -1), + Trans(8, 108, 28, -1), + Trans(8, 116, 44, -1), + Trans(8, 117, 45, -1), Trans(9, 5, 39, -1), Trans(9, 6, 46, -1), Trans(9, 7, 46, -1), @@ -7230,14 +7297,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(9, 40, 22, -1), Trans(9, 42, 22, -1), Trans(9, 54, 22, -1), - Trans(9, 71, 22, -1), - Trans(9, 77, 22, -1), - Trans(9, 84, 46, -1), - Trans(9, 87, 46, -1), - Trans(9, 89, 22, -1), - Trans(9, 106, 28, -1), - Trans(9, 114, 47, -1), - Trans(9, 115, 48, -1), + Trans(9, 72, 22, -1), + Trans(9, 78, 22, -1), + Trans(9, 85, 46, -1), + Trans(9, 88, 46, -1), + Trans(9, 90, 22, -1), + Trans(9, 108, 28, -1), + Trans(9, 116, 47, -1), + Trans(9, 117, 48, -1), Trans(10, 5, 20, -1), Trans(10, 6, 21, -1), Trans(10, 7, 21, -1), @@ -7260,35 +7327,35 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(10, 50, 29, -1), Trans(10, 51, 23, -1), Trans(10, 54, 22, -1), - Trans(10, 58, 30, -1), - Trans(10, 59, 31, -1), - Trans(10, 61, 23, -1), - Trans(10, 62, 32, -1), - Trans(10, 65, 28, -1), - Trans(10, 66, 23, -1), + Trans(10, 59, 30, -1), + Trans(10, 60, 31, -1), + Trans(10, 62, 23, -1), + Trans(10, 63, 32, -1), + Trans(10, 66, 28, -1), Trans(10, 67, 23, -1), - Trans(10, 70, 28, -1), - Trans(10, 71, 22, -1), - Trans(10, 72, 33, -1), - Trans(10, 74, 28, -1), - Trans(10, 77, 22, -1), - Trans(10, 78, 23, -1), - Trans(10, 81, 23, -1), + Trans(10, 68, 23, -1), + Trans(10, 71, 28, -1), + Trans(10, 72, 22, -1), + Trans(10, 73, 33, -1), + Trans(10, 75, 28, -1), + Trans(10, 78, 22, -1), + Trans(10, 79, 23, -1), Trans(10, 82, 23, -1), - Trans(10, 84, 21, -1), - Trans(10, 85, 23, -1), - Trans(10, 87, 21, -1), - Trans(10, 89, 22, -1), - Trans(10, 100, 22, -1), - Trans(10, 101, 34, -1), - Trans(10, 105, 23, -1), - Trans(10, 106, 28, -1), - Trans(10, 108, 23, -1), - Trans(10, 111, 23, -1), - Trans(10, 112, 35, -1), + Trans(10, 83, 23, -1), + Trans(10, 85, 21, -1), + Trans(10, 86, 23, -1), + Trans(10, 88, 21, -1), + Trans(10, 90, 22, -1), + Trans(10, 102, 22, -1), + Trans(10, 103, 34, -1), + Trans(10, 107, 23, -1), + Trans(10, 108, 28, -1), + Trans(10, 110, 23, -1), Trans(10, 113, 23, -1), - Trans(10, 114, 36, -1), - Trans(10, 115, 37, -1), + Trans(10, 114, 35, -1), + Trans(10, 115, 23, -1), + Trans(10, 116, 36, -1), + Trans(10, 117, 37, -1), Trans(11, 5, 39, -1), Trans(11, 6, 49, -1), Trans(11, 7, 49, -1), @@ -7305,18 +7372,18 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(11, 40, 22, -1), Trans(11, 42, 22, -1), Trans(11, 54, 22, -1), - Trans(11, 71, 22, -1), - Trans(11, 77, 22, -1), - Trans(11, 84, 49, -1), - Trans(11, 87, 49, -1), - Trans(11, 89, 22, -1), - Trans(11, 106, 28, -1), - Trans(11, 114, 50, -1), - Trans(11, 115, 51, -1), + Trans(11, 72, 22, -1), + Trans(11, 78, 22, -1), + Trans(11, 85, 49, -1), + Trans(11, 88, 49, -1), + Trans(11, 90, 22, -1), + Trans(11, 108, 28, -1), + Trans(11, 116, 50, -1), + Trans(11, 117, 51, -1), Trans(12, 5, 62, -1), Trans(12, 31, 56, -1), Trans(13, 5, 68, -1), - Trans(13, 115, 30, -1), + Trans(13, 117, 30, -1), Trans(14, 5, 64, -1), Trans(14, 40, 63, -1), Trans(15, 5, 39, -1), @@ -7335,14 +7402,14 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(15, 40, 22, -1), Trans(15, 42, 22, -1), Trans(15, 54, 22, -1), - Trans(15, 71, 22, -1), - Trans(15, 77, 22, -1), - Trans(15, 84, 52, -1), - Trans(15, 87, 52, -1), - Trans(15, 89, 22, -1), - Trans(15, 106, 28, -1), - Trans(15, 114, 53, -1), - Trans(15, 115, 54, -1), + Trans(15, 72, 22, -1), + Trans(15, 78, 22, -1), + Trans(15, 85, 52, -1), + Trans(15, 88, 52, -1), + Trans(15, 90, 22, -1), + Trans(15, 108, 28, -1), + Trans(15, 116, 53, -1), + Trans(15, 117, 54, -1), Trans(16, 5, 66, -1), Trans(16, 47, 67, -1), Trans(17, 5, 64, -1), @@ -7396,1163 +7463,1164 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(19, 42, 57, -1), Trans(19, 48, 22, -1), Trans(19, 52, 58, -1), - Trans(20, 6, 38, 566), - Trans(20, 7, 38, 566), - Trans(20, 8, 38, 566), - Trans(20, 9, 38, 566), - Trans(20, 10, 38, 566), - Trans(20, 11, 38, 566), - Trans(20, 18, 38, 566), - Trans(20, 24, 38, 566), - Trans(20, 25, 38, 566), - Trans(20, 26, 38, 566), - Trans(20, 27, 38, 566), - Trans(20, 31, 38, 566), - Trans(20, 37, 38, 566), - Trans(20, 39, 38, 566), - Trans(20, 40, 38, 566), - Trans(20, 42, 38, 566), - Trans(20, 44, 38, 566), - Trans(20, 49, 38, 566), - Trans(20, 50, 38, 566), - Trans(20, 51, 38, 566), - Trans(20, 54, 38, 566), - Trans(20, 58, 38, 566), - Trans(20, 59, 38, 566), - Trans(20, 61, 38, 566), - Trans(20, 62, 38, 566), - Trans(20, 65, 38, 566), - Trans(20, 66, 38, 566), - Trans(20, 67, 38, 566), - Trans(20, 70, 38, 566), - Trans(20, 71, 38, 566), - Trans(20, 72, 38, 566), - Trans(20, 74, 38, 566), - Trans(20, 77, 38, 566), - Trans(20, 78, 38, 566), - Trans(20, 81, 38, 566), - Trans(20, 82, 38, 566), - Trans(20, 84, 38, 566), - Trans(20, 85, 38, 566), - Trans(20, 87, 38, 566), - Trans(20, 89, 38, 566), - Trans(20, 100, 38, 566), - Trans(20, 101, 38, 566), - Trans(20, 105, 38, 566), - Trans(20, 106, 38, 566), - Trans(20, 108, 38, 566), - Trans(20, 111, 38, 566), - Trans(20, 112, 38, 566), - Trans(20, 113, 38, 566), - Trans(20, 114, 38, 566), - Trans(20, 115, 38, 566), - Trans(21, 5, 38, 566), - Trans(21, 16, 38, 566), - Trans(21, 17, 38, 566), - Trans(21, 18, 38, 566), - Trans(21, 19, 38, 566), - Trans(21, 20, 38, 566), - Trans(21, 21, 38, 566), - Trans(21, 22, 38, 566), - Trans(21, 23, 38, 566), - Trans(21, 24, 38, 566), - Trans(21, 25, 38, 566), - Trans(21, 26, 38, 566), - Trans(21, 31, 38, 566), - Trans(21, 32, 38, 566), - Trans(21, 33, 38, 566), - Trans(21, 34, 38, 566), - Trans(21, 48, 38, 566), - Trans(21, 52, 38, 566), - Trans(22, 5, 38, 566), - Trans(22, 6, 38, 566), - Trans(22, 7, 38, 566), - Trans(22, 8, 38, 566), - Trans(22, 9, 38, 566), - Trans(22, 10, 38, 566), - Trans(22, 11, 38, 566), - Trans(22, 18, 38, 566), - Trans(22, 24, 38, 566), - Trans(22, 25, 38, 566), - Trans(22, 26, 38, 566), - Trans(22, 27, 38, 566), - Trans(22, 39, 38, 566), - Trans(22, 40, 38, 566), - Trans(22, 42, 38, 566), - Trans(22, 54, 38, 566), - Trans(22, 71, 38, 566), - Trans(22, 77, 38, 566), - Trans(22, 84, 38, 566), - Trans(22, 87, 38, 566), - Trans(22, 89, 38, 566), - Trans(22, 106, 38, 566), - Trans(22, 114, 38, 566), - Trans(22, 115, 38, 566), - Trans(23, 5, 38, 566), - Trans(23, 115, 38, 566), - Trans(24, 5, 38, 566), - Trans(24, 41, 38, 566), - Trans(25, 5, 38, 566), - Trans(25, 6, 38, 566), - Trans(25, 7, 38, 566), - Trans(25, 8, 38, 566), - Trans(25, 9, 38, 566), - Trans(25, 10, 38, 566), - Trans(25, 11, 38, 566), - Trans(25, 18, 38, 566), - Trans(25, 24, 38, 566), - Trans(25, 25, 38, 566), - Trans(25, 26, 38, 566), - Trans(25, 27, 38, 566), - Trans(25, 39, 38, 566), - Trans(25, 40, 38, 566), - Trans(25, 42, 38, 566), - Trans(25, 54, 38, 566), - Trans(25, 58, 38, 566), - Trans(25, 71, 38, 566), - Trans(25, 77, 38, 566), - Trans(25, 84, 38, 566), - Trans(25, 87, 38, 566), - Trans(25, 89, 38, 566), - Trans(25, 106, 38, 566), - Trans(25, 114, 38, 566), - Trans(25, 115, 38, 566), - Trans(26, 5, 38, 566), - Trans(26, 6, 38, 566), - Trans(26, 7, 38, 566), - Trans(26, 8, 38, 566), - Trans(26, 9, 38, 566), - Trans(26, 10, 38, 566), - Trans(26, 11, 38, 566), - Trans(26, 18, 38, 566), - Trans(26, 24, 38, 566), - Trans(26, 25, 38, 566), - Trans(26, 26, 38, 566), - Trans(26, 27, 38, 566), - Trans(26, 31, 38, 566), - Trans(26, 37, 38, 566), - Trans(26, 39, 38, 566), - Trans(26, 40, 38, 566), - Trans(26, 42, 38, 566), - Trans(26, 44, 38, 566), - Trans(26, 49, 38, 566), - Trans(26, 50, 38, 566), - Trans(26, 51, 38, 566), - Trans(26, 54, 38, 566), - Trans(26, 61, 38, 566), - Trans(26, 62, 38, 566), - Trans(26, 65, 38, 566), - Trans(26, 66, 38, 566), - Trans(26, 67, 38, 566), - Trans(26, 71, 38, 566), - Trans(26, 72, 38, 566), - Trans(26, 74, 38, 566), - Trans(26, 77, 38, 566), - Trans(26, 78, 38, 566), - Trans(26, 81, 38, 566), - Trans(26, 82, 38, 566), - Trans(26, 84, 38, 566), - Trans(26, 85, 38, 566), - Trans(26, 87, 38, 566), - Trans(26, 89, 38, 566), - Trans(26, 105, 38, 566), - Trans(26, 106, 38, 566), - Trans(26, 108, 38, 566), - Trans(26, 111, 38, 566), - Trans(26, 112, 38, 566), - Trans(26, 113, 38, 566), - Trans(26, 114, 38, 566), - Trans(26, 115, 38, 566), - Trans(27, 0, 38, 566), - Trans(27, 5, 38, 566), - Trans(27, 6, 38, 566), - Trans(27, 7, 38, 566), - Trans(27, 8, 38, 566), - Trans(27, 9, 38, 566), - Trans(27, 10, 38, 566), - Trans(27, 11, 38, 566), - Trans(27, 18, 38, 566), - Trans(27, 24, 38, 566), - Trans(27, 25, 38, 566), - Trans(27, 26, 38, 566), - Trans(27, 27, 38, 566), - Trans(27, 31, 38, 566), - Trans(27, 37, 38, 566), - Trans(27, 39, 38, 566), - Trans(27, 40, 38, 566), - Trans(27, 42, 38, 566), - Trans(27, 44, 38, 566), - Trans(27, 49, 38, 566), - Trans(27, 50, 38, 566), - Trans(27, 51, 38, 566), - Trans(27, 54, 38, 566), - Trans(27, 58, 38, 566), - Trans(27, 59, 38, 566), - Trans(27, 60, 38, 566), - Trans(27, 61, 38, 566), - Trans(27, 62, 38, 566), - Trans(27, 65, 38, 566), - Trans(27, 66, 38, 566), - Trans(27, 67, 38, 566), - Trans(27, 70, 38, 566), - Trans(27, 71, 38, 566), - Trans(27, 72, 38, 566), - Trans(27, 73, 38, 566), - Trans(27, 74, 38, 566), - Trans(27, 77, 38, 566), - Trans(27, 78, 38, 566), - Trans(27, 79, 38, 566), - Trans(27, 81, 38, 566), - Trans(27, 82, 38, 566), - Trans(27, 84, 38, 566), - Trans(27, 85, 38, 566), - Trans(27, 86, 38, 566), - Trans(27, 87, 38, 566), - Trans(27, 89, 38, 566), - Trans(27, 90, 38, 566), - Trans(27, 92, 38, 566), - Trans(27, 100, 38, 566), - Trans(27, 101, 38, 566), - Trans(27, 105, 38, 566), - Trans(27, 106, 38, 566), - Trans(27, 108, 38, 566), - Trans(27, 111, 38, 566), - Trans(27, 112, 38, 566), - Trans(27, 113, 38, 566), - Trans(27, 114, 38, 566), - Trans(27, 115, 38, 566), - Trans(28, 5, 38, 566), - Trans(28, 40, 38, 566), - Trans(29, 5, 38, 566), - Trans(29, 40, 38, 566), - Trans(29, 42, 38, 566), - Trans(30, 5, 38, 566), - Trans(30, 31, 38, 566), - Trans(31, 5, 38, 566), - Trans(31, 40, 38, 566), - Trans(31, 71, 38, 566), - Trans(32, 5, 38, 566), - Trans(32, 48, 38, 566), - Trans(32, 114, 38, 566), - Trans(32, 115, 38, 566), - Trans(33, 5, 38, 566), - Trans(33, 114, 38, 566), - Trans(33, 115, 38, 566), - Trans(34, 5, 38, 566), - Trans(34, 47, 38, 566), - Trans(35, 5, 38, 566), - Trans(35, 42, 38, 566), - Trans(36, 5, 38, 566), - Trans(36, 15, 38, 566), - Trans(36, 16, 38, 566), - Trans(36, 17, 38, 566), - Trans(36, 18, 38, 566), - Trans(36, 19, 38, 566), - Trans(36, 20, 38, 566), - Trans(36, 21, 38, 566), - Trans(36, 22, 38, 566), - Trans(36, 23, 38, 566), - Trans(36, 24, 38, 566), - Trans(36, 25, 38, 566), - Trans(36, 26, 38, 566), - Trans(36, 30, 38, 566), - Trans(36, 31, 38, 566), - Trans(36, 32, 38, 566), - Trans(36, 33, 38, 566), - Trans(36, 34, 38, 566), - Trans(36, 35, 38, 566), - Trans(36, 36, 38, 566), - Trans(36, 41, 38, 566), - Trans(36, 42, 38, 566), - Trans(36, 48, 38, 566), - Trans(36, 52, 38, 566), - Trans(37, 5, 38, 566), - Trans(37, 15, 38, 566), - Trans(37, 16, 38, 566), - Trans(37, 17, 38, 566), - Trans(37, 18, 38, 566), - Trans(37, 19, 38, 566), - Trans(37, 20, 38, 566), - Trans(37, 21, 38, 566), - Trans(37, 22, 38, 566), - Trans(37, 23, 38, 566), - Trans(37, 24, 38, 566), - Trans(37, 25, 38, 566), - Trans(37, 26, 38, 566), - Trans(37, 29, 38, 566), - Trans(37, 30, 38, 566), - Trans(37, 31, 38, 566), - Trans(37, 32, 38, 566), - Trans(37, 33, 38, 566), - Trans(37, 34, 38, 566), - Trans(37, 35, 38, 566), - Trans(37, 36, 38, 566), - Trans(37, 41, 38, 566), - Trans(37, 42, 38, 566), - Trans(37, 48, 38, 566), - Trans(37, 52, 38, 566), - Trans(39, 6, 38, 566), - Trans(39, 7, 38, 566), - Trans(39, 8, 38, 566), - Trans(39, 9, 38, 566), - Trans(39, 10, 38, 566), - Trans(39, 11, 38, 566), - Trans(39, 18, 38, 566), - Trans(39, 24, 38, 566), - Trans(39, 25, 38, 566), - Trans(39, 26, 38, 566), - Trans(39, 27, 38, 566), - Trans(39, 39, 38, 566), - Trans(39, 40, 38, 566), - Trans(39, 42, 38, 566), - Trans(39, 54, 38, 566), - Trans(39, 71, 38, 566), - Trans(39, 77, 38, 566), - Trans(39, 84, 38, 566), - Trans(39, 87, 38, 566), - Trans(39, 89, 38, 566), - Trans(39, 106, 38, 566), - Trans(39, 114, 38, 566), - Trans(39, 115, 38, 566), - Trans(40, 5, 38, 566), - Trans(40, 16, 38, 566), - Trans(40, 17, 38, 566), - Trans(40, 18, 38, 566), - Trans(40, 19, 38, 566), - Trans(40, 20, 38, 566), - Trans(40, 21, 38, 566), - Trans(40, 22, 38, 566), - Trans(40, 23, 38, 566), - Trans(40, 24, 38, 566), - Trans(40, 25, 38, 566), - Trans(40, 26, 38, 566), - Trans(40, 30, 38, 566), - Trans(40, 31, 38, 566), - Trans(40, 32, 38, 566), - Trans(40, 33, 38, 566), - Trans(40, 34, 38, 566), - Trans(40, 35, 38, 566), - Trans(40, 41, 38, 566), - Trans(40, 42, 38, 566), - Trans(40, 48, 38, 566), - Trans(40, 52, 38, 566), - Trans(41, 5, 38, 566), - Trans(41, 16, 38, 566), - Trans(41, 17, 38, 566), - Trans(41, 18, 38, 566), - Trans(41, 19, 38, 566), - Trans(41, 20, 38, 566), - Trans(41, 21, 38, 566), - Trans(41, 22, 38, 566), - Trans(41, 23, 38, 566), - Trans(41, 24, 38, 566), - Trans(41, 25, 38, 566), - Trans(41, 26, 38, 566), - Trans(41, 29, 38, 566), - Trans(41, 30, 38, 566), - Trans(41, 31, 38, 566), - Trans(41, 32, 38, 566), - Trans(41, 33, 38, 566), - Trans(41, 34, 38, 566), - Trans(41, 35, 38, 566), - Trans(41, 41, 38, 566), - Trans(41, 42, 38, 566), - Trans(41, 48, 38, 566), - Trans(41, 52, 38, 566), - Trans(42, 6, 38, 566), - Trans(42, 7, 38, 566), - Trans(42, 8, 38, 566), - Trans(42, 9, 38, 566), - Trans(42, 10, 38, 566), - Trans(42, 11, 38, 566), - Trans(42, 18, 38, 566), - Trans(42, 24, 38, 566), - Trans(42, 25, 38, 566), - Trans(42, 26, 38, 566), - Trans(42, 27, 38, 566), - Trans(42, 39, 38, 566), - Trans(42, 40, 38, 566), - Trans(42, 42, 38, 566), - Trans(42, 54, 38, 566), - Trans(42, 58, 38, 566), - Trans(42, 71, 38, 566), - Trans(42, 77, 38, 566), - Trans(42, 84, 38, 566), - Trans(42, 87, 38, 566), - Trans(42, 89, 38, 566), - Trans(42, 106, 38, 566), - Trans(42, 114, 38, 566), - Trans(42, 115, 38, 566), - Trans(43, 5, 38, 566), - Trans(43, 16, 38, 566), - Trans(43, 17, 38, 566), - Trans(43, 18, 38, 566), - Trans(43, 19, 38, 566), - Trans(43, 20, 38, 566), - Trans(43, 21, 38, 566), - Trans(43, 22, 38, 566), - Trans(43, 23, 38, 566), - Trans(43, 24, 38, 566), - Trans(43, 25, 38, 566), - Trans(43, 26, 38, 566), - Trans(43, 32, 38, 566), - Trans(43, 44, 38, 566), - Trans(43, 48, 38, 566), - Trans(43, 52, 38, 566), - Trans(43, 94, 38, 566), - Trans(44, 5, 38, 566), - Trans(44, 16, 38, 566), - Trans(44, 17, 38, 566), - Trans(44, 18, 38, 566), - Trans(44, 19, 38, 566), - Trans(44, 20, 38, 566), - Trans(44, 21, 38, 566), - Trans(44, 22, 38, 566), - Trans(44, 23, 38, 566), - Trans(44, 24, 38, 566), - Trans(44, 25, 38, 566), - Trans(44, 26, 38, 566), - Trans(44, 30, 38, 566), - Trans(44, 32, 38, 566), - Trans(44, 35, 38, 566), - Trans(44, 41, 38, 566), - Trans(44, 42, 38, 566), - Trans(44, 44, 38, 566), - Trans(44, 48, 38, 566), - Trans(44, 52, 38, 566), - Trans(44, 94, 38, 566), - Trans(45, 5, 38, 566), - Trans(45, 16, 38, 566), - Trans(45, 17, 38, 566), - Trans(45, 18, 38, 566), - Trans(45, 19, 38, 566), - Trans(45, 20, 38, 566), - Trans(45, 21, 38, 566), - Trans(45, 22, 38, 566), - Trans(45, 23, 38, 566), - Trans(45, 24, 38, 566), - Trans(45, 25, 38, 566), - Trans(45, 26, 38, 566), - Trans(45, 29, 38, 566), - Trans(45, 30, 38, 566), - Trans(45, 32, 38, 566), - Trans(45, 35, 38, 566), - Trans(45, 41, 38, 566), - Trans(45, 42, 38, 566), - Trans(45, 44, 38, 566), - Trans(45, 48, 38, 566), - Trans(45, 52, 38, 566), - Trans(45, 94, 38, 566), - Trans(46, 5, 38, 566), - Trans(46, 16, 38, 566), - Trans(46, 17, 38, 566), - Trans(46, 18, 38, 566), - Trans(46, 19, 38, 566), - Trans(46, 20, 38, 566), - Trans(46, 21, 38, 566), - Trans(46, 22, 38, 566), - Trans(46, 23, 38, 566), - Trans(46, 24, 38, 566), - Trans(46, 25, 38, 566), - Trans(46, 26, 38, 566), - Trans(46, 46, 38, 566), - Trans(46, 48, 38, 566), - Trans(46, 52, 38, 566), - Trans(47, 5, 38, 566), - Trans(47, 16, 38, 566), - Trans(47, 17, 38, 566), - Trans(47, 18, 38, 566), - Trans(47, 19, 38, 566), - Trans(47, 20, 38, 566), - Trans(47, 21, 38, 566), - Trans(47, 22, 38, 566), - Trans(47, 23, 38, 566), - Trans(47, 24, 38, 566), - Trans(47, 25, 38, 566), - Trans(47, 26, 38, 566), - Trans(47, 30, 38, 566), - Trans(47, 35, 38, 566), - Trans(47, 41, 38, 566), - Trans(47, 42, 38, 566), - Trans(47, 46, 38, 566), - Trans(47, 48, 38, 566), - Trans(47, 52, 38, 566), - Trans(48, 5, 38, 566), - Trans(48, 16, 38, 566), - Trans(48, 17, 38, 566), - Trans(48, 18, 38, 566), - Trans(48, 19, 38, 566), - Trans(48, 20, 38, 566), - Trans(48, 21, 38, 566), - Trans(48, 22, 38, 566), - Trans(48, 23, 38, 566), - Trans(48, 24, 38, 566), - Trans(48, 25, 38, 566), - Trans(48, 26, 38, 566), - Trans(48, 29, 38, 566), - Trans(48, 30, 38, 566), - Trans(48, 35, 38, 566), - Trans(48, 41, 38, 566), - Trans(48, 42, 38, 566), - Trans(48, 46, 38, 566), - Trans(48, 48, 38, 566), - Trans(48, 52, 38, 566), - Trans(49, 5, 38, 566), - Trans(49, 16, 38, 566), - Trans(49, 17, 38, 566), - Trans(49, 18, 38, 566), - Trans(49, 19, 38, 566), - Trans(49, 20, 38, 566), - Trans(49, 21, 38, 566), - Trans(49, 22, 38, 566), - Trans(49, 23, 38, 566), - Trans(49, 24, 38, 566), - Trans(49, 25, 38, 566), - Trans(49, 26, 38, 566), - Trans(49, 40, 38, 566), - Trans(49, 48, 38, 566), - Trans(49, 52, 38, 566), - Trans(50, 5, 38, 566), - Trans(50, 16, 38, 566), - Trans(50, 17, 38, 566), - Trans(50, 18, 38, 566), - Trans(50, 19, 38, 566), - Trans(50, 20, 38, 566), - Trans(50, 21, 38, 566), - Trans(50, 22, 38, 566), - Trans(50, 23, 38, 566), - Trans(50, 24, 38, 566), - Trans(50, 25, 38, 566), - Trans(50, 26, 38, 566), - Trans(50, 30, 38, 566), - Trans(50, 35, 38, 566), - Trans(50, 40, 38, 566), - Trans(50, 41, 38, 566), - Trans(50, 42, 38, 566), - Trans(50, 48, 38, 566), - Trans(50, 52, 38, 566), - Trans(51, 5, 38, 566), - Trans(51, 16, 38, 566), - Trans(51, 17, 38, 566), - Trans(51, 18, 38, 566), - Trans(51, 19, 38, 566), - Trans(51, 20, 38, 566), - Trans(51, 21, 38, 566), - Trans(51, 22, 38, 566), - Trans(51, 23, 38, 566), - Trans(51, 24, 38, 566), - Trans(51, 25, 38, 566), - Trans(51, 26, 38, 566), - Trans(51, 29, 38, 566), - Trans(51, 30, 38, 566), - Trans(51, 35, 38, 566), - Trans(51, 40, 38, 566), - Trans(51, 41, 38, 566), - Trans(51, 42, 38, 566), - Trans(51, 48, 38, 566), - Trans(51, 52, 38, 566), - Trans(52, 5, 38, 566), - Trans(52, 16, 38, 566), - Trans(52, 17, 38, 566), - Trans(52, 18, 38, 566), - Trans(52, 19, 38, 566), - Trans(52, 20, 38, 566), - Trans(52, 21, 38, 566), - Trans(52, 22, 38, 566), - Trans(52, 23, 38, 566), - Trans(52, 24, 38, 566), - Trans(52, 25, 38, 566), - Trans(52, 26, 38, 566), - Trans(52, 47, 38, 566), - Trans(52, 48, 38, 566), - Trans(52, 52, 38, 566), - Trans(53, 5, 38, 566), - Trans(53, 16, 38, 566), - Trans(53, 17, 38, 566), - Trans(53, 18, 38, 566), - Trans(53, 19, 38, 566), - Trans(53, 20, 38, 566), - Trans(53, 21, 38, 566), - Trans(53, 22, 38, 566), - Trans(53, 23, 38, 566), - Trans(53, 24, 38, 566), - Trans(53, 25, 38, 566), - Trans(53, 26, 38, 566), - Trans(53, 30, 38, 566), - Trans(53, 35, 38, 566), - Trans(53, 41, 38, 566), - Trans(53, 42, 38, 566), - Trans(53, 47, 38, 566), - Trans(53, 48, 38, 566), - Trans(53, 52, 38, 566), - Trans(54, 5, 38, 566), - Trans(54, 16, 38, 566), - Trans(54, 17, 38, 566), - Trans(54, 18, 38, 566), - Trans(54, 19, 38, 566), - Trans(54, 20, 38, 566), - Trans(54, 21, 38, 566), - Trans(54, 22, 38, 566), - Trans(54, 23, 38, 566), - Trans(54, 24, 38, 566), - Trans(54, 25, 38, 566), - Trans(54, 26, 38, 566), - Trans(54, 29, 38, 566), - Trans(54, 30, 38, 566), - Trans(54, 35, 38, 566), - Trans(54, 41, 38, 566), - Trans(54, 42, 38, 566), - Trans(54, 47, 38, 566), - Trans(54, 48, 38, 566), - Trans(54, 52, 38, 566), - Trans(55, 15, 38, 566), - Trans(55, 16, 38, 566), - Trans(55, 17, 38, 566), - Trans(55, 18, 38, 566), - Trans(55, 19, 38, 566), - Trans(55, 20, 38, 566), - Trans(55, 21, 38, 566), - Trans(55, 22, 38, 566), - Trans(55, 23, 38, 566), - Trans(55, 24, 38, 566), - Trans(55, 25, 38, 566), - Trans(55, 26, 38, 566), - Trans(55, 30, 38, 566), - Trans(55, 31, 38, 566), - Trans(55, 32, 38, 566), - Trans(55, 33, 38, 566), - Trans(55, 34, 38, 566), - Trans(55, 35, 38, 566), - Trans(55, 36, 38, 566), - Trans(55, 41, 38, 566), - Trans(55, 42, 38, 566), - Trans(55, 48, 38, 566), - Trans(55, 52, 38, 566), - Trans(56, 5, 38, 566), - Trans(56, 40, 38, 566), - Trans(56, 54, 38, 566), - Trans(56, 66, 38, 566), - Trans(56, 70, 38, 566), - Trans(56, 71, 38, 566), - Trans(56, 81, 38, 566), - Trans(56, 100, 38, 566), - Trans(56, 101, 38, 566), - Trans(56, 106, 38, 566), - Trans(56, 114, 38, 566), - Trans(56, 115, 38, 566), - Trans(57, 5, 38, 566), - Trans(57, 6, 38, 566), - Trans(57, 7, 38, 566), - Trans(57, 8, 38, 566), - Trans(57, 9, 38, 566), - Trans(57, 10, 38, 566), - Trans(57, 11, 38, 566), - Trans(57, 18, 38, 566), - Trans(57, 24, 38, 566), - Trans(57, 25, 38, 566), - Trans(57, 26, 38, 566), - Trans(57, 27, 38, 566), - Trans(57, 39, 38, 566), - Trans(57, 40, 38, 566), - Trans(57, 42, 38, 566), - Trans(57, 46, 38, 566), - Trans(57, 54, 38, 566), - Trans(57, 71, 38, 566), - Trans(57, 77, 38, 566), - Trans(57, 84, 38, 566), - Trans(57, 87, 38, 566), - Trans(57, 89, 38, 566), - Trans(57, 106, 38, 566), - Trans(57, 114, 38, 566), - Trans(57, 115, 38, 566), - Trans(58, 5, 38, 566), - Trans(58, 55, 38, 566), - Trans(58, 56, 38, 566), - Trans(58, 57, 38, 566), - Trans(58, 63, 38, 566), - Trans(58, 64, 38, 566), - Trans(58, 68, 38, 566), - Trans(58, 69, 38, 566), - Trans(58, 95, 38, 566), - Trans(58, 96, 38, 566), - Trans(58, 97, 38, 566), - Trans(58, 98, 38, 566), - Trans(58, 99, 38, 566), - Trans(58, 109, 38, 566), - Trans(58, 110, 38, 566), - Trans(58, 114, 38, 566), - Trans(58, 115, 38, 566), - Trans(59, 15, 38, 566), - Trans(59, 16, 38, 566), - Trans(59, 17, 38, 566), - Trans(59, 18, 38, 566), - Trans(59, 19, 38, 566), - Trans(59, 20, 38, 566), - Trans(59, 21, 38, 566), - Trans(59, 22, 38, 566), - Trans(59, 23, 38, 566), - Trans(59, 24, 38, 566), - Trans(59, 25, 38, 566), - Trans(59, 26, 38, 566), - Trans(59, 29, 38, 566), - Trans(59, 30, 38, 566), - Trans(59, 31, 38, 566), - Trans(59, 32, 38, 566), - Trans(59, 33, 38, 566), - Trans(59, 34, 38, 566), - Trans(59, 35, 38, 566), - Trans(59, 36, 38, 566), - Trans(59, 41, 38, 566), - Trans(59, 42, 38, 566), - Trans(59, 48, 38, 566), - Trans(59, 52, 38, 566), - Trans(60, 5, 38, 566), - Trans(60, 7, 38, 566), - Trans(60, 8, 38, 566), - Trans(60, 9, 38, 566), - Trans(60, 10, 38, 566), - Trans(60, 11, 38, 566), - Trans(60, 43, 38, 566), - Trans(60, 114, 38, 566), - Trans(60, 115, 38, 566), - Trans(61, 16, 38, 566), - Trans(61, 17, 38, 566), - Trans(61, 18, 38, 566), - Trans(61, 19, 38, 566), - Trans(61, 20, 38, 566), - Trans(61, 21, 38, 566), - Trans(61, 22, 38, 566), - Trans(61, 23, 38, 566), - Trans(61, 24, 38, 566), - Trans(61, 25, 38, 566), - Trans(61, 26, 38, 566), - Trans(61, 31, 38, 566), - Trans(61, 32, 38, 566), - Trans(61, 33, 38, 566), - Trans(61, 34, 38, 566), - Trans(61, 48, 38, 566), - Trans(61, 52, 38, 566), - Trans(62, 31, 38, 566), - Trans(63, 5, 38, 566), - Trans(63, 44, 38, 566), - Trans(63, 54, 38, 566), - Trans(63, 66, 38, 566), - Trans(63, 70, 38, 566), - Trans(63, 71, 38, 566), - Trans(63, 81, 38, 566), - Trans(63, 100, 38, 566), - Trans(63, 101, 38, 566), - Trans(63, 106, 38, 566), - Trans(63, 114, 38, 566), - Trans(63, 115, 38, 566), - Trans(64, 40, 38, 566), - Trans(65, 5, 38, 566), - Trans(65, 6, 38, 566), - Trans(65, 7, 38, 566), - Trans(65, 8, 38, 566), - Trans(65, 9, 38, 566), - Trans(65, 10, 38, 566), - Trans(65, 11, 38, 566), - Trans(65, 18, 38, 566), - Trans(65, 24, 38, 566), - Trans(65, 25, 38, 566), - Trans(65, 26, 38, 566), - Trans(65, 27, 38, 566), - Trans(65, 39, 38, 566), - Trans(65, 40, 38, 566), - Trans(65, 42, 38, 566), - Trans(65, 44, 38, 566), - Trans(65, 54, 38, 566), - Trans(65, 58, 38, 566), - Trans(65, 71, 38, 566), - Trans(65, 77, 38, 566), - Trans(65, 84, 38, 566), - Trans(65, 87, 38, 566), - Trans(65, 89, 38, 566), - Trans(65, 106, 38, 566), - Trans(65, 114, 38, 566), - Trans(65, 115, 38, 566), - Trans(66, 47, 38, 566), - Trans(67, 5, 38, 566), - Trans(67, 44, 38, 566), - Trans(67, 54, 38, 566), - Trans(67, 66, 38, 566), - Trans(67, 70, 38, 566), - Trans(67, 71, 38, 566), - Trans(67, 81, 38, 566), - Trans(67, 100, 38, 566), - Trans(67, 101, 38, 566), - Trans(67, 106, 38, 566), - Trans(67, 113, 38, 566), - Trans(67, 114, 38, 566), - Trans(67, 115, 38, 566), - Trans(68, 115, 38, 566), + Trans(20, 6, 38, 571), + Trans(20, 7, 38, 571), + Trans(20, 8, 38, 571), + Trans(20, 9, 38, 571), + Trans(20, 10, 38, 571), + Trans(20, 11, 38, 571), + Trans(20, 18, 38, 571), + Trans(20, 24, 38, 571), + Trans(20, 25, 38, 571), + Trans(20, 26, 38, 571), + Trans(20, 27, 38, 571), + Trans(20, 31, 38, 571), + Trans(20, 37, 38, 571), + Trans(20, 39, 38, 571), + Trans(20, 40, 38, 571), + Trans(20, 42, 38, 571), + Trans(20, 44, 38, 571), + Trans(20, 49, 38, 571), + Trans(20, 50, 38, 571), + Trans(20, 51, 38, 571), + Trans(20, 54, 38, 571), + Trans(20, 59, 38, 571), + Trans(20, 60, 38, 571), + Trans(20, 62, 38, 571), + Trans(20, 63, 38, 571), + Trans(20, 66, 38, 571), + Trans(20, 67, 38, 571), + Trans(20, 68, 38, 571), + Trans(20, 71, 38, 571), + Trans(20, 72, 38, 571), + Trans(20, 73, 38, 571), + Trans(20, 75, 38, 571), + Trans(20, 78, 38, 571), + Trans(20, 79, 38, 571), + Trans(20, 82, 38, 571), + Trans(20, 83, 38, 571), + Trans(20, 85, 38, 571), + Trans(20, 86, 38, 571), + Trans(20, 88, 38, 571), + Trans(20, 90, 38, 571), + Trans(20, 102, 38, 571), + Trans(20, 103, 38, 571), + Trans(20, 107, 38, 571), + Trans(20, 108, 38, 571), + Trans(20, 110, 38, 571), + Trans(20, 113, 38, 571), + Trans(20, 114, 38, 571), + Trans(20, 115, 38, 571), + Trans(20, 116, 38, 571), + Trans(20, 117, 38, 571), + Trans(21, 5, 38, 571), + Trans(21, 16, 38, 571), + Trans(21, 17, 38, 571), + Trans(21, 18, 38, 571), + Trans(21, 19, 38, 571), + Trans(21, 20, 38, 571), + Trans(21, 21, 38, 571), + Trans(21, 22, 38, 571), + Trans(21, 23, 38, 571), + Trans(21, 24, 38, 571), + Trans(21, 25, 38, 571), + Trans(21, 26, 38, 571), + Trans(21, 31, 38, 571), + Trans(21, 32, 38, 571), + Trans(21, 33, 38, 571), + Trans(21, 34, 38, 571), + Trans(21, 48, 38, 571), + Trans(21, 52, 38, 571), + Trans(22, 5, 38, 571), + Trans(22, 6, 38, 571), + Trans(22, 7, 38, 571), + Trans(22, 8, 38, 571), + Trans(22, 9, 38, 571), + Trans(22, 10, 38, 571), + Trans(22, 11, 38, 571), + Trans(22, 18, 38, 571), + Trans(22, 24, 38, 571), + Trans(22, 25, 38, 571), + Trans(22, 26, 38, 571), + Trans(22, 27, 38, 571), + Trans(22, 39, 38, 571), + Trans(22, 40, 38, 571), + Trans(22, 42, 38, 571), + Trans(22, 54, 38, 571), + Trans(22, 72, 38, 571), + Trans(22, 78, 38, 571), + Trans(22, 85, 38, 571), + Trans(22, 88, 38, 571), + Trans(22, 90, 38, 571), + Trans(22, 108, 38, 571), + Trans(22, 116, 38, 571), + Trans(22, 117, 38, 571), + Trans(23, 5, 38, 571), + Trans(23, 117, 38, 571), + Trans(24, 5, 38, 571), + Trans(24, 41, 38, 571), + Trans(25, 5, 38, 571), + Trans(25, 6, 38, 571), + Trans(25, 7, 38, 571), + Trans(25, 8, 38, 571), + Trans(25, 9, 38, 571), + Trans(25, 10, 38, 571), + Trans(25, 11, 38, 571), + Trans(25, 18, 38, 571), + Trans(25, 24, 38, 571), + Trans(25, 25, 38, 571), + Trans(25, 26, 38, 571), + Trans(25, 27, 38, 571), + Trans(25, 39, 38, 571), + Trans(25, 40, 38, 571), + Trans(25, 42, 38, 571), + Trans(25, 54, 38, 571), + Trans(25, 59, 38, 571), + Trans(25, 72, 38, 571), + Trans(25, 78, 38, 571), + Trans(25, 85, 38, 571), + Trans(25, 88, 38, 571), + Trans(25, 90, 38, 571), + Trans(25, 108, 38, 571), + Trans(25, 116, 38, 571), + Trans(25, 117, 38, 571), + Trans(26, 5, 38, 571), + Trans(26, 6, 38, 571), + Trans(26, 7, 38, 571), + Trans(26, 8, 38, 571), + Trans(26, 9, 38, 571), + Trans(26, 10, 38, 571), + Trans(26, 11, 38, 571), + Trans(26, 18, 38, 571), + Trans(26, 24, 38, 571), + Trans(26, 25, 38, 571), + Trans(26, 26, 38, 571), + Trans(26, 27, 38, 571), + Trans(26, 31, 38, 571), + Trans(26, 37, 38, 571), + Trans(26, 39, 38, 571), + Trans(26, 40, 38, 571), + Trans(26, 42, 38, 571), + Trans(26, 44, 38, 571), + Trans(26, 49, 38, 571), + Trans(26, 50, 38, 571), + Trans(26, 51, 38, 571), + Trans(26, 54, 38, 571), + Trans(26, 62, 38, 571), + Trans(26, 63, 38, 571), + Trans(26, 66, 38, 571), + Trans(26, 67, 38, 571), + Trans(26, 68, 38, 571), + Trans(26, 72, 38, 571), + Trans(26, 73, 38, 571), + Trans(26, 75, 38, 571), + Trans(26, 78, 38, 571), + Trans(26, 79, 38, 571), + Trans(26, 82, 38, 571), + Trans(26, 83, 38, 571), + Trans(26, 85, 38, 571), + Trans(26, 86, 38, 571), + Trans(26, 88, 38, 571), + Trans(26, 90, 38, 571), + Trans(26, 107, 38, 571), + Trans(26, 108, 38, 571), + Trans(26, 110, 38, 571), + Trans(26, 113, 38, 571), + Trans(26, 114, 38, 571), + Trans(26, 115, 38, 571), + Trans(26, 116, 38, 571), + Trans(26, 117, 38, 571), + Trans(27, 0, 38, 571), + Trans(27, 5, 38, 571), + Trans(27, 6, 38, 571), + Trans(27, 7, 38, 571), + Trans(27, 8, 38, 571), + Trans(27, 9, 38, 571), + Trans(27, 10, 38, 571), + Trans(27, 11, 38, 571), + Trans(27, 18, 38, 571), + Trans(27, 24, 38, 571), + Trans(27, 25, 38, 571), + Trans(27, 26, 38, 571), + Trans(27, 27, 38, 571), + Trans(27, 31, 38, 571), + Trans(27, 37, 38, 571), + Trans(27, 39, 38, 571), + Trans(27, 40, 38, 571), + Trans(27, 42, 38, 571), + Trans(27, 44, 38, 571), + Trans(27, 49, 38, 571), + Trans(27, 50, 38, 571), + Trans(27, 51, 38, 571), + Trans(27, 54, 38, 571), + Trans(27, 59, 38, 571), + Trans(27, 60, 38, 571), + Trans(27, 61, 38, 571), + Trans(27, 62, 38, 571), + Trans(27, 63, 38, 571), + Trans(27, 66, 38, 571), + Trans(27, 67, 38, 571), + Trans(27, 68, 38, 571), + Trans(27, 71, 38, 571), + Trans(27, 72, 38, 571), + Trans(27, 73, 38, 571), + Trans(27, 74, 38, 571), + Trans(27, 75, 38, 571), + Trans(27, 78, 38, 571), + Trans(27, 79, 38, 571), + Trans(27, 80, 38, 571), + Trans(27, 82, 38, 571), + Trans(27, 83, 38, 571), + Trans(27, 85, 38, 571), + Trans(27, 86, 38, 571), + Trans(27, 87, 38, 571), + Trans(27, 88, 38, 571), + Trans(27, 90, 38, 571), + Trans(27, 91, 38, 571), + Trans(27, 93, 38, 571), + Trans(27, 94, 38, 571), + Trans(27, 102, 38, 571), + Trans(27, 103, 38, 571), + Trans(27, 107, 38, 571), + Trans(27, 108, 38, 571), + Trans(27, 110, 38, 571), + Trans(27, 113, 38, 571), + Trans(27, 114, 38, 571), + Trans(27, 115, 38, 571), + Trans(27, 116, 38, 571), + Trans(27, 117, 38, 571), + Trans(28, 5, 38, 571), + Trans(28, 40, 38, 571), + Trans(29, 5, 38, 571), + Trans(29, 40, 38, 571), + Trans(29, 42, 38, 571), + Trans(30, 5, 38, 571), + Trans(30, 31, 38, 571), + Trans(31, 5, 38, 571), + Trans(31, 40, 38, 571), + Trans(31, 72, 38, 571), + Trans(32, 5, 38, 571), + Trans(32, 48, 38, 571), + Trans(32, 116, 38, 571), + Trans(32, 117, 38, 571), + Trans(33, 5, 38, 571), + Trans(33, 116, 38, 571), + Trans(33, 117, 38, 571), + Trans(34, 5, 38, 571), + Trans(34, 47, 38, 571), + Trans(35, 5, 38, 571), + Trans(35, 42, 38, 571), + Trans(36, 5, 38, 571), + Trans(36, 15, 38, 571), + Trans(36, 16, 38, 571), + Trans(36, 17, 38, 571), + Trans(36, 18, 38, 571), + Trans(36, 19, 38, 571), + Trans(36, 20, 38, 571), + Trans(36, 21, 38, 571), + Trans(36, 22, 38, 571), + Trans(36, 23, 38, 571), + Trans(36, 24, 38, 571), + Trans(36, 25, 38, 571), + Trans(36, 26, 38, 571), + Trans(36, 30, 38, 571), + Trans(36, 31, 38, 571), + Trans(36, 32, 38, 571), + Trans(36, 33, 38, 571), + Trans(36, 34, 38, 571), + Trans(36, 35, 38, 571), + Trans(36, 36, 38, 571), + Trans(36, 41, 38, 571), + Trans(36, 42, 38, 571), + Trans(36, 48, 38, 571), + Trans(36, 52, 38, 571), + Trans(37, 5, 38, 571), + Trans(37, 15, 38, 571), + Trans(37, 16, 38, 571), + Trans(37, 17, 38, 571), + Trans(37, 18, 38, 571), + Trans(37, 19, 38, 571), + Trans(37, 20, 38, 571), + Trans(37, 21, 38, 571), + Trans(37, 22, 38, 571), + Trans(37, 23, 38, 571), + Trans(37, 24, 38, 571), + Trans(37, 25, 38, 571), + Trans(37, 26, 38, 571), + Trans(37, 29, 38, 571), + Trans(37, 30, 38, 571), + Trans(37, 31, 38, 571), + Trans(37, 32, 38, 571), + Trans(37, 33, 38, 571), + Trans(37, 34, 38, 571), + Trans(37, 35, 38, 571), + Trans(37, 36, 38, 571), + Trans(37, 41, 38, 571), + Trans(37, 42, 38, 571), + Trans(37, 48, 38, 571), + Trans(37, 52, 38, 571), + Trans(39, 6, 38, 571), + Trans(39, 7, 38, 571), + Trans(39, 8, 38, 571), + Trans(39, 9, 38, 571), + Trans(39, 10, 38, 571), + Trans(39, 11, 38, 571), + Trans(39, 18, 38, 571), + Trans(39, 24, 38, 571), + Trans(39, 25, 38, 571), + Trans(39, 26, 38, 571), + Trans(39, 27, 38, 571), + Trans(39, 39, 38, 571), + Trans(39, 40, 38, 571), + Trans(39, 42, 38, 571), + Trans(39, 54, 38, 571), + Trans(39, 72, 38, 571), + Trans(39, 78, 38, 571), + Trans(39, 85, 38, 571), + Trans(39, 88, 38, 571), + Trans(39, 90, 38, 571), + Trans(39, 108, 38, 571), + Trans(39, 116, 38, 571), + Trans(39, 117, 38, 571), + Trans(40, 5, 38, 571), + Trans(40, 16, 38, 571), + Trans(40, 17, 38, 571), + Trans(40, 18, 38, 571), + Trans(40, 19, 38, 571), + Trans(40, 20, 38, 571), + Trans(40, 21, 38, 571), + Trans(40, 22, 38, 571), + Trans(40, 23, 38, 571), + Trans(40, 24, 38, 571), + Trans(40, 25, 38, 571), + Trans(40, 26, 38, 571), + Trans(40, 30, 38, 571), + Trans(40, 31, 38, 571), + Trans(40, 32, 38, 571), + Trans(40, 33, 38, 571), + Trans(40, 34, 38, 571), + Trans(40, 35, 38, 571), + Trans(40, 41, 38, 571), + Trans(40, 42, 38, 571), + Trans(40, 48, 38, 571), + Trans(40, 52, 38, 571), + Trans(41, 5, 38, 571), + Trans(41, 16, 38, 571), + Trans(41, 17, 38, 571), + Trans(41, 18, 38, 571), + Trans(41, 19, 38, 571), + Trans(41, 20, 38, 571), + Trans(41, 21, 38, 571), + Trans(41, 22, 38, 571), + Trans(41, 23, 38, 571), + Trans(41, 24, 38, 571), + Trans(41, 25, 38, 571), + Trans(41, 26, 38, 571), + Trans(41, 29, 38, 571), + Trans(41, 30, 38, 571), + Trans(41, 31, 38, 571), + Trans(41, 32, 38, 571), + Trans(41, 33, 38, 571), + Trans(41, 34, 38, 571), + Trans(41, 35, 38, 571), + Trans(41, 41, 38, 571), + Trans(41, 42, 38, 571), + Trans(41, 48, 38, 571), + Trans(41, 52, 38, 571), + Trans(42, 6, 38, 571), + Trans(42, 7, 38, 571), + Trans(42, 8, 38, 571), + Trans(42, 9, 38, 571), + Trans(42, 10, 38, 571), + Trans(42, 11, 38, 571), + Trans(42, 18, 38, 571), + Trans(42, 24, 38, 571), + Trans(42, 25, 38, 571), + Trans(42, 26, 38, 571), + Trans(42, 27, 38, 571), + Trans(42, 39, 38, 571), + Trans(42, 40, 38, 571), + Trans(42, 42, 38, 571), + Trans(42, 54, 38, 571), + Trans(42, 59, 38, 571), + Trans(42, 72, 38, 571), + Trans(42, 78, 38, 571), + Trans(42, 85, 38, 571), + Trans(42, 88, 38, 571), + Trans(42, 90, 38, 571), + Trans(42, 108, 38, 571), + Trans(42, 116, 38, 571), + Trans(42, 117, 38, 571), + Trans(43, 5, 38, 571), + Trans(43, 16, 38, 571), + Trans(43, 17, 38, 571), + Trans(43, 18, 38, 571), + Trans(43, 19, 38, 571), + Trans(43, 20, 38, 571), + Trans(43, 21, 38, 571), + Trans(43, 22, 38, 571), + Trans(43, 23, 38, 571), + Trans(43, 24, 38, 571), + Trans(43, 25, 38, 571), + Trans(43, 26, 38, 571), + Trans(43, 32, 38, 571), + Trans(43, 44, 38, 571), + Trans(43, 48, 38, 571), + Trans(43, 52, 38, 571), + Trans(43, 96, 38, 571), + Trans(44, 5, 38, 571), + Trans(44, 16, 38, 571), + Trans(44, 17, 38, 571), + Trans(44, 18, 38, 571), + Trans(44, 19, 38, 571), + Trans(44, 20, 38, 571), + Trans(44, 21, 38, 571), + Trans(44, 22, 38, 571), + Trans(44, 23, 38, 571), + Trans(44, 24, 38, 571), + Trans(44, 25, 38, 571), + Trans(44, 26, 38, 571), + Trans(44, 30, 38, 571), + Trans(44, 32, 38, 571), + Trans(44, 35, 38, 571), + Trans(44, 41, 38, 571), + Trans(44, 42, 38, 571), + Trans(44, 44, 38, 571), + Trans(44, 48, 38, 571), + Trans(44, 52, 38, 571), + Trans(44, 96, 38, 571), + Trans(45, 5, 38, 571), + Trans(45, 16, 38, 571), + Trans(45, 17, 38, 571), + Trans(45, 18, 38, 571), + Trans(45, 19, 38, 571), + Trans(45, 20, 38, 571), + Trans(45, 21, 38, 571), + Trans(45, 22, 38, 571), + Trans(45, 23, 38, 571), + Trans(45, 24, 38, 571), + Trans(45, 25, 38, 571), + Trans(45, 26, 38, 571), + Trans(45, 29, 38, 571), + Trans(45, 30, 38, 571), + Trans(45, 32, 38, 571), + Trans(45, 35, 38, 571), + Trans(45, 41, 38, 571), + Trans(45, 42, 38, 571), + Trans(45, 44, 38, 571), + Trans(45, 48, 38, 571), + Trans(45, 52, 38, 571), + Trans(45, 96, 38, 571), + Trans(46, 5, 38, 571), + Trans(46, 16, 38, 571), + Trans(46, 17, 38, 571), + Trans(46, 18, 38, 571), + Trans(46, 19, 38, 571), + Trans(46, 20, 38, 571), + Trans(46, 21, 38, 571), + Trans(46, 22, 38, 571), + Trans(46, 23, 38, 571), + Trans(46, 24, 38, 571), + Trans(46, 25, 38, 571), + Trans(46, 26, 38, 571), + Trans(46, 46, 38, 571), + Trans(46, 48, 38, 571), + Trans(46, 52, 38, 571), + Trans(47, 5, 38, 571), + Trans(47, 16, 38, 571), + Trans(47, 17, 38, 571), + Trans(47, 18, 38, 571), + Trans(47, 19, 38, 571), + Trans(47, 20, 38, 571), + Trans(47, 21, 38, 571), + Trans(47, 22, 38, 571), + Trans(47, 23, 38, 571), + Trans(47, 24, 38, 571), + Trans(47, 25, 38, 571), + Trans(47, 26, 38, 571), + Trans(47, 30, 38, 571), + Trans(47, 35, 38, 571), + Trans(47, 41, 38, 571), + Trans(47, 42, 38, 571), + Trans(47, 46, 38, 571), + Trans(47, 48, 38, 571), + Trans(47, 52, 38, 571), + Trans(48, 5, 38, 571), + Trans(48, 16, 38, 571), + Trans(48, 17, 38, 571), + Trans(48, 18, 38, 571), + Trans(48, 19, 38, 571), + Trans(48, 20, 38, 571), + Trans(48, 21, 38, 571), + Trans(48, 22, 38, 571), + Trans(48, 23, 38, 571), + Trans(48, 24, 38, 571), + Trans(48, 25, 38, 571), + Trans(48, 26, 38, 571), + Trans(48, 29, 38, 571), + Trans(48, 30, 38, 571), + Trans(48, 35, 38, 571), + Trans(48, 41, 38, 571), + Trans(48, 42, 38, 571), + Trans(48, 46, 38, 571), + Trans(48, 48, 38, 571), + Trans(48, 52, 38, 571), + Trans(49, 5, 38, 571), + Trans(49, 16, 38, 571), + Trans(49, 17, 38, 571), + Trans(49, 18, 38, 571), + Trans(49, 19, 38, 571), + Trans(49, 20, 38, 571), + Trans(49, 21, 38, 571), + Trans(49, 22, 38, 571), + Trans(49, 23, 38, 571), + Trans(49, 24, 38, 571), + Trans(49, 25, 38, 571), + Trans(49, 26, 38, 571), + Trans(49, 40, 38, 571), + Trans(49, 48, 38, 571), + Trans(49, 52, 38, 571), + Trans(50, 5, 38, 571), + Trans(50, 16, 38, 571), + Trans(50, 17, 38, 571), + Trans(50, 18, 38, 571), + Trans(50, 19, 38, 571), + Trans(50, 20, 38, 571), + Trans(50, 21, 38, 571), + Trans(50, 22, 38, 571), + Trans(50, 23, 38, 571), + Trans(50, 24, 38, 571), + Trans(50, 25, 38, 571), + Trans(50, 26, 38, 571), + Trans(50, 30, 38, 571), + Trans(50, 35, 38, 571), + Trans(50, 40, 38, 571), + Trans(50, 41, 38, 571), + Trans(50, 42, 38, 571), + Trans(50, 48, 38, 571), + Trans(50, 52, 38, 571), + Trans(51, 5, 38, 571), + Trans(51, 16, 38, 571), + Trans(51, 17, 38, 571), + Trans(51, 18, 38, 571), + Trans(51, 19, 38, 571), + Trans(51, 20, 38, 571), + Trans(51, 21, 38, 571), + Trans(51, 22, 38, 571), + Trans(51, 23, 38, 571), + Trans(51, 24, 38, 571), + Trans(51, 25, 38, 571), + Trans(51, 26, 38, 571), + Trans(51, 29, 38, 571), + Trans(51, 30, 38, 571), + Trans(51, 35, 38, 571), + Trans(51, 40, 38, 571), + Trans(51, 41, 38, 571), + Trans(51, 42, 38, 571), + Trans(51, 48, 38, 571), + Trans(51, 52, 38, 571), + Trans(52, 5, 38, 571), + Trans(52, 16, 38, 571), + Trans(52, 17, 38, 571), + Trans(52, 18, 38, 571), + Trans(52, 19, 38, 571), + Trans(52, 20, 38, 571), + Trans(52, 21, 38, 571), + Trans(52, 22, 38, 571), + Trans(52, 23, 38, 571), + Trans(52, 24, 38, 571), + Trans(52, 25, 38, 571), + Trans(52, 26, 38, 571), + Trans(52, 47, 38, 571), + Trans(52, 48, 38, 571), + Trans(52, 52, 38, 571), + Trans(53, 5, 38, 571), + Trans(53, 16, 38, 571), + Trans(53, 17, 38, 571), + Trans(53, 18, 38, 571), + Trans(53, 19, 38, 571), + Trans(53, 20, 38, 571), + Trans(53, 21, 38, 571), + Trans(53, 22, 38, 571), + Trans(53, 23, 38, 571), + Trans(53, 24, 38, 571), + Trans(53, 25, 38, 571), + Trans(53, 26, 38, 571), + Trans(53, 30, 38, 571), + Trans(53, 35, 38, 571), + Trans(53, 41, 38, 571), + Trans(53, 42, 38, 571), + Trans(53, 47, 38, 571), + Trans(53, 48, 38, 571), + Trans(53, 52, 38, 571), + Trans(54, 5, 38, 571), + Trans(54, 16, 38, 571), + Trans(54, 17, 38, 571), + Trans(54, 18, 38, 571), + Trans(54, 19, 38, 571), + Trans(54, 20, 38, 571), + Trans(54, 21, 38, 571), + Trans(54, 22, 38, 571), + Trans(54, 23, 38, 571), + Trans(54, 24, 38, 571), + Trans(54, 25, 38, 571), + Trans(54, 26, 38, 571), + Trans(54, 29, 38, 571), + Trans(54, 30, 38, 571), + Trans(54, 35, 38, 571), + Trans(54, 41, 38, 571), + Trans(54, 42, 38, 571), + Trans(54, 47, 38, 571), + Trans(54, 48, 38, 571), + Trans(54, 52, 38, 571), + Trans(55, 15, 38, 571), + Trans(55, 16, 38, 571), + Trans(55, 17, 38, 571), + Trans(55, 18, 38, 571), + Trans(55, 19, 38, 571), + Trans(55, 20, 38, 571), + Trans(55, 21, 38, 571), + Trans(55, 22, 38, 571), + Trans(55, 23, 38, 571), + Trans(55, 24, 38, 571), + Trans(55, 25, 38, 571), + Trans(55, 26, 38, 571), + Trans(55, 30, 38, 571), + Trans(55, 31, 38, 571), + Trans(55, 32, 38, 571), + Trans(55, 33, 38, 571), + Trans(55, 34, 38, 571), + Trans(55, 35, 38, 571), + Trans(55, 36, 38, 571), + Trans(55, 41, 38, 571), + Trans(55, 42, 38, 571), + Trans(55, 48, 38, 571), + Trans(55, 52, 38, 571), + Trans(56, 5, 38, 571), + Trans(56, 40, 38, 571), + Trans(56, 54, 38, 571), + Trans(56, 67, 38, 571), + Trans(56, 71, 38, 571), + Trans(56, 72, 38, 571), + Trans(56, 82, 38, 571), + Trans(56, 102, 38, 571), + Trans(56, 103, 38, 571), + Trans(56, 108, 38, 571), + Trans(56, 116, 38, 571), + Trans(56, 117, 38, 571), + Trans(57, 5, 38, 571), + Trans(57, 6, 38, 571), + Trans(57, 7, 38, 571), + Trans(57, 8, 38, 571), + Trans(57, 9, 38, 571), + Trans(57, 10, 38, 571), + Trans(57, 11, 38, 571), + Trans(57, 18, 38, 571), + Trans(57, 24, 38, 571), + Trans(57, 25, 38, 571), + Trans(57, 26, 38, 571), + Trans(57, 27, 38, 571), + Trans(57, 39, 38, 571), + Trans(57, 40, 38, 571), + Trans(57, 42, 38, 571), + Trans(57, 46, 38, 571), + Trans(57, 54, 38, 571), + Trans(57, 72, 38, 571), + Trans(57, 78, 38, 571), + Trans(57, 85, 38, 571), + Trans(57, 88, 38, 571), + Trans(57, 90, 38, 571), + Trans(57, 108, 38, 571), + Trans(57, 116, 38, 571), + Trans(57, 117, 38, 571), + Trans(58, 5, 38, 571), + Trans(58, 55, 38, 571), + Trans(58, 56, 38, 571), + Trans(58, 57, 38, 571), + Trans(58, 64, 38, 571), + Trans(58, 65, 38, 571), + Trans(58, 69, 38, 571), + Trans(58, 70, 38, 571), + Trans(58, 97, 38, 571), + Trans(58, 98, 38, 571), + Trans(58, 99, 38, 571), + Trans(58, 100, 38, 571), + Trans(58, 101, 38, 571), + Trans(58, 111, 38, 571), + Trans(58, 112, 38, 571), + Trans(58, 116, 38, 571), + Trans(58, 117, 38, 571), + Trans(59, 15, 38, 571), + Trans(59, 16, 38, 571), + Trans(59, 17, 38, 571), + Trans(59, 18, 38, 571), + Trans(59, 19, 38, 571), + Trans(59, 20, 38, 571), + Trans(59, 21, 38, 571), + Trans(59, 22, 38, 571), + Trans(59, 23, 38, 571), + Trans(59, 24, 38, 571), + Trans(59, 25, 38, 571), + Trans(59, 26, 38, 571), + Trans(59, 29, 38, 571), + Trans(59, 30, 38, 571), + Trans(59, 31, 38, 571), + Trans(59, 32, 38, 571), + Trans(59, 33, 38, 571), + Trans(59, 34, 38, 571), + Trans(59, 35, 38, 571), + Trans(59, 36, 38, 571), + Trans(59, 41, 38, 571), + Trans(59, 42, 38, 571), + Trans(59, 48, 38, 571), + Trans(59, 52, 38, 571), + Trans(60, 5, 38, 571), + Trans(60, 7, 38, 571), + Trans(60, 8, 38, 571), + Trans(60, 9, 38, 571), + Trans(60, 10, 38, 571), + Trans(60, 11, 38, 571), + Trans(60, 43, 38, 571), + Trans(60, 116, 38, 571), + Trans(60, 117, 38, 571), + Trans(61, 16, 38, 571), + Trans(61, 17, 38, 571), + Trans(61, 18, 38, 571), + Trans(61, 19, 38, 571), + Trans(61, 20, 38, 571), + Trans(61, 21, 38, 571), + Trans(61, 22, 38, 571), + Trans(61, 23, 38, 571), + Trans(61, 24, 38, 571), + Trans(61, 25, 38, 571), + Trans(61, 26, 38, 571), + Trans(61, 31, 38, 571), + Trans(61, 32, 38, 571), + Trans(61, 33, 38, 571), + Trans(61, 34, 38, 571), + Trans(61, 48, 38, 571), + Trans(61, 52, 38, 571), + Trans(62, 31, 38, 571), + Trans(63, 5, 38, 571), + Trans(63, 44, 38, 571), + Trans(63, 54, 38, 571), + Trans(63, 67, 38, 571), + Trans(63, 71, 38, 571), + Trans(63, 72, 38, 571), + Trans(63, 82, 38, 571), + Trans(63, 102, 38, 571), + Trans(63, 103, 38, 571), + Trans(63, 108, 38, 571), + Trans(63, 116, 38, 571), + Trans(63, 117, 38, 571), + Trans(64, 40, 38, 571), + Trans(65, 5, 38, 571), + Trans(65, 6, 38, 571), + Trans(65, 7, 38, 571), + Trans(65, 8, 38, 571), + Trans(65, 9, 38, 571), + Trans(65, 10, 38, 571), + Trans(65, 11, 38, 571), + Trans(65, 18, 38, 571), + Trans(65, 24, 38, 571), + Trans(65, 25, 38, 571), + Trans(65, 26, 38, 571), + Trans(65, 27, 38, 571), + Trans(65, 39, 38, 571), + Trans(65, 40, 38, 571), + Trans(65, 42, 38, 571), + Trans(65, 44, 38, 571), + Trans(65, 54, 38, 571), + Trans(65, 59, 38, 571), + Trans(65, 72, 38, 571), + Trans(65, 78, 38, 571), + Trans(65, 85, 38, 571), + Trans(65, 88, 38, 571), + Trans(65, 90, 38, 571), + Trans(65, 108, 38, 571), + Trans(65, 116, 38, 571), + Trans(65, 117, 38, 571), + Trans(66, 47, 38, 571), + Trans(67, 5, 38, 571), + Trans(67, 44, 38, 571), + Trans(67, 54, 38, 571), + Trans(67, 67, 38, 571), + Trans(67, 71, 38, 571), + Trans(67, 72, 38, 571), + Trans(67, 82, 38, 571), + Trans(67, 102, 38, 571), + Trans(67, 103, 38, 571), + Trans(67, 108, 38, 571), + Trans(67, 115, 38, 571), + Trans(67, 116, 38, 571), + Trans(67, 117, 38, 571), + Trans(68, 117, 38, 571), ], k: 3, }, - /* 270 - "IfStatementList0List" */ + /* 274 - "IfStatementList0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 565), - Trans(0, 54, 1, 564), - Trans(0, 66, 1, 564), - Trans(0, 70, 1, 564), - Trans(0, 71, 1, 564), - Trans(0, 81, 1, 564), - Trans(0, 100, 1, 564), - Trans(0, 101, 1, 564), - Trans(0, 106, 1, 564), - Trans(0, 114, 1, 564), - Trans(0, 115, 1, 564), + Trans(0, 44, 2, 570), + Trans(0, 54, 1, 569), + Trans(0, 67, 1, 569), + Trans(0, 71, 1, 569), + Trans(0, 72, 1, 569), + Trans(0, 82, 1, 569), + Trans(0, 102, 1, 569), + Trans(0, 103, 1, 569), + Trans(0, 108, 1, 569), + Trans(0, 116, 1, 569), + Trans(0, 117, 1, 569), ], k: 1, }, - /* 271 - "IfStatementOpt" */ + /* 275 - "IfStatementOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 2, 572), - Trans(0, 7, 2, 572), - Trans(0, 8, 2, 572), - Trans(0, 9, 2, 572), - Trans(0, 10, 2, 572), - Trans(0, 11, 2, 572), - Trans(0, 18, 2, 572), - Trans(0, 24, 2, 572), - Trans(0, 25, 2, 572), - Trans(0, 26, 2, 572), - Trans(0, 27, 2, 572), - Trans(0, 39, 2, 572), - Trans(0, 40, 2, 572), - Trans(0, 42, 2, 572), - Trans(0, 44, 2, 572), - Trans(0, 54, 2, 572), - Trans(0, 58, 2, 572), - Trans(0, 59, 1, 569), - Trans(0, 66, 2, 572), - Trans(0, 70, 2, 572), - Trans(0, 71, 2, 572), - Trans(0, 77, 2, 572), - Trans(0, 81, 2, 572), - Trans(0, 84, 2, 572), - Trans(0, 87, 2, 572), - Trans(0, 89, 2, 572), - Trans(0, 100, 2, 572), - Trans(0, 101, 2, 572), - Trans(0, 106, 2, 572), - Trans(0, 113, 2, 572), - Trans(0, 114, 2, 572), - Trans(0, 115, 2, 572), + Trans(0, 6, 2, 577), + Trans(0, 7, 2, 577), + Trans(0, 8, 2, 577), + Trans(0, 9, 2, 577), + Trans(0, 10, 2, 577), + Trans(0, 11, 2, 577), + Trans(0, 18, 2, 577), + Trans(0, 24, 2, 577), + Trans(0, 25, 2, 577), + Trans(0, 26, 2, 577), + Trans(0, 27, 2, 577), + Trans(0, 39, 2, 577), + Trans(0, 40, 2, 577), + Trans(0, 42, 2, 577), + Trans(0, 44, 2, 577), + Trans(0, 54, 2, 577), + Trans(0, 59, 2, 577), + Trans(0, 60, 1, 574), + Trans(0, 67, 2, 577), + Trans(0, 71, 2, 577), + Trans(0, 72, 2, 577), + Trans(0, 78, 2, 577), + Trans(0, 82, 2, 577), + Trans(0, 85, 2, 577), + Trans(0, 88, 2, 577), + Trans(0, 90, 2, 577), + Trans(0, 102, 2, 577), + Trans(0, 103, 2, 577), + Trans(0, 108, 2, 577), + Trans(0, 115, 2, 577), + Trans(0, 116, 2, 577), + Trans(0, 117, 2, 577), ], k: 1, }, - /* 272 - "IfStatementOptList" */ + /* 276 - "IfStatementOptList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 571), - Trans(0, 54, 1, 570), - Trans(0, 66, 1, 570), - Trans(0, 70, 1, 570), - Trans(0, 71, 1, 570), - Trans(0, 81, 1, 570), - Trans(0, 100, 1, 570), - Trans(0, 101, 1, 570), - Trans(0, 106, 1, 570), - Trans(0, 114, 1, 570), - Trans(0, 115, 1, 570), + Trans(0, 44, 2, 576), + Trans(0, 54, 1, 575), + Trans(0, 67, 1, 575), + Trans(0, 71, 1, 575), + Trans(0, 72, 1, 575), + Trans(0, 82, 1, 575), + Trans(0, 102, 1, 575), + Trans(0, 103, 1, 575), + Trans(0, 108, 1, 575), + Trans(0, 116, 1, 575), + Trans(0, 117, 1, 575), ], k: 1, }, - /* 273 - "IfTerm" */ + /* 277 - "IfTerm" */ LookaheadDFA { - prod0: 66, + prod0: 67, transitions: &[], k: 0, }, - /* 274 - "IfToken" */ + /* 278 - "IfToken" */ LookaheadDFA { - prod0: 181, + prod0: 184, transitions: &[], k: 0, }, - /* 275 - "Import" */ + /* 279 - "Import" */ LookaheadDFA { - prod0: 294, + prod0: 299, transitions: &[], k: 0, }, - /* 276 - "ImportDeclaration" */ + /* 280 - "ImportDeclaration" */ LookaheadDFA { - prod0: 817, + prod0: 825, transitions: &[], k: 0, }, - /* 277 - "ImportDeclarationOpt" */ + /* 281 - "ImportDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 818), Trans(0, 47, 2, 819)], + transitions: &[Trans(0, 30, 1, 826), Trans(0, 47, 2, 827)], k: 1, }, - /* 278 - "ImportTerm" */ + /* 282 - "ImportTerm" */ LookaheadDFA { - prod0: 67, + prod0: 68, transitions: &[], k: 0, }, - /* 279 - "ImportToken" */ + /* 283 - "ImportToken" */ LookaheadDFA { - prod0: 182, + prod0: 185, transitions: &[], k: 0, }, - /* 280 - "In" */ + /* 284 - "In" */ LookaheadDFA { - prod0: 295, + prod0: 300, transitions: &[], k: 0, }, - /* 281 - "InTerm" */ + /* 285 - "InTerm" */ LookaheadDFA { - prod0: 75, + prod0: 76, transitions: &[], k: 0, }, - /* 282 - "InToken" */ + /* 286 - "InToken" */ LookaheadDFA { - prod0: 190, + prod0: 193, transitions: &[], k: 0, }, - /* 283 - "Include" */ + /* 287 - "Include" */ LookaheadDFA { - prod0: 296, + prod0: 301, transitions: &[], k: 0, }, - /* 284 - "IncludeDeclaration" */ + /* 288 - "IncludeDeclaration" */ LookaheadDFA { - prod0: 959, + prod0: 976, transitions: &[], k: 0, }, - /* 285 - "IncludeTerm" */ + /* 289 - "IncludeTerm" */ LookaheadDFA { - prod0: 68, + prod0: 69, transitions: &[], k: 0, }, - /* 286 - "IncludeToken" */ + /* 290 - "IncludeToken" */ LookaheadDFA { - prod0: 183, + prod0: 186, transitions: &[], k: 0, }, - /* 287 - "Initial" */ + /* 291 - "Initial" */ LookaheadDFA { - prod0: 297, + prod0: 302, transitions: &[], k: 0, }, - /* 288 - "InitialDeclaration" */ + /* 292 - "InitialDeclaration" */ LookaheadDFA { - prod0: 695, + prod0: 700, transitions: &[], k: 0, }, - /* 289 - "InitialDeclarationList" */ + /* 293 - "InitialDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 697), - Trans(0, 54, 1, 696), - Trans(0, 66, 1, 696), - Trans(0, 70, 1, 696), - Trans(0, 71, 1, 696), - Trans(0, 81, 1, 696), - Trans(0, 100, 1, 696), - Trans(0, 101, 1, 696), - Trans(0, 106, 1, 696), - Trans(0, 114, 1, 696), - Trans(0, 115, 1, 696), + Trans(0, 44, 2, 702), + Trans(0, 54, 1, 701), + Trans(0, 67, 1, 701), + Trans(0, 71, 1, 701), + Trans(0, 72, 1, 701), + Trans(0, 82, 1, 701), + Trans(0, 102, 1, 701), + Trans(0, 103, 1, 701), + Trans(0, 108, 1, 701), + Trans(0, 116, 1, 701), + Trans(0, 117, 1, 701), ], k: 1, }, - /* 290 - "InitialTerm" */ + /* 294 - "InitialTerm" */ LookaheadDFA { - prod0: 69, + prod0: 70, transitions: &[], k: 0, }, - /* 291 - "InitialToken" */ + /* 295 - "InitialToken" */ LookaheadDFA { - prod0: 184, + prod0: 187, transitions: &[], k: 0, }, - /* 292 - "Inout" */ + /* 296 - "Inout" */ LookaheadDFA { - prod0: 298, + prod0: 303, transitions: &[], k: 0, }, - /* 293 - "InoutTerm" */ + /* 297 - "InoutTerm" */ LookaheadDFA { - prod0: 70, + prod0: 71, transitions: &[], k: 0, }, - /* 294 - "InoutToken" */ + /* 298 - "InoutToken" */ LookaheadDFA { - prod0: 185, + prod0: 188, transitions: &[], k: 0, }, - /* 295 - "Input" */ + /* 299 - "Input" */ LookaheadDFA { - prod0: 299, + prod0: 304, transitions: &[], k: 0, }, - /* 296 - "InputTerm" */ + /* 300 - "InputTerm" */ LookaheadDFA { - prod0: 71, + prod0: 72, transitions: &[], k: 0, }, - /* 297 - "InputToken" */ + /* 301 - "InputToken" */ LookaheadDFA { - prod0: 186, + prod0: 189, transitions: &[], k: 0, }, - /* 298 - "Inside" */ + /* 302 - "Inside" */ LookaheadDFA { - prod0: 300, + prod0: 305, transitions: &[], k: 0, }, - /* 299 - "InsideExpression" */ + /* 303 - "InsideExpression" */ LookaheadDFA { - prod0: 471, + prod0: 477, transitions: &[], k: 0, }, - /* 300 - "InsideTerm" */ + /* 304 - "InsideTerm" */ LookaheadDFA { - prod0: 72, + prod0: 73, transitions: &[], k: 0, }, - /* 301 - "InsideToken" */ + /* 305 - "InsideToken" */ LookaheadDFA { - prod0: 187, + prod0: 190, transitions: &[], k: 0, }, - /* 302 - "Inst" */ + /* 306 - "Inst" */ LookaheadDFA { - prod0: 301, + prod0: 306, transitions: &[], k: 0, }, - /* 303 - "InstDeclaration" */ + /* 307 - "InstDeclaration" */ LookaheadDFA { - prod0: 701, + prod0: 706, transitions: &[], k: 0, }, - /* 304 - "InstDeclarationOpt" */ + /* 308 - "InstDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 2, 709), - Trans(0, 41, 1, 708), - Trans(0, 42, 2, 709), - Trans(0, 47, 2, 709), + Trans(0, 37, 2, 714), + Trans(0, 41, 1, 713), + Trans(0, 42, 2, 714), + Trans(0, 47, 2, 714), ], k: 1, }, - /* 305 - "InstDeclarationOpt0" */ + /* 309 - "InstDeclarationOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 706), - Trans(0, 42, 2, 707), - Trans(0, 47, 2, 707), + Trans(0, 37, 1, 711), + Trans(0, 42, 2, 712), + Trans(0, 47, 2, 712), ], k: 1, }, - /* 306 - "InstDeclarationOpt1" */ + /* 310 - "InstDeclarationOpt1" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 42, 1, 702), Trans(0, 47, 2, 705)], + transitions: &[Trans(0, 42, 1, 707), Trans(0, 47, 2, 710)], k: 1, }, - /* 307 - "InstDeclarationOpt2" */ + /* 311 - "InstDeclarationOpt2" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 703), - Trans(0, 40, 1, 703), - Trans(0, 46, 2, 704), - Trans(0, 115, 1, 703), + Trans(0, 37, 1, 708), + Trans(0, 40, 1, 708), + Trans(0, 46, 2, 709), + Trans(0, 117, 1, 708), ], k: 1, }, - /* 308 - "InstParameter" */ + /* 312 - "InstParameter" */ LookaheadDFA { - prod0: 710, + prod0: 715, transitions: &[], k: 0, }, - /* 309 - "InstParameterGroup" */ + /* 313 - "InstParameterGroup" */ LookaheadDFA { - prod0: 718, + prod0: 723, transitions: &[], k: 0, }, - /* 310 - "InstParameterGroupGroup" */ + /* 314 - "InstParameterGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 719), Trans(0, 115, 2, 720)], + transitions: &[Trans(0, 40, 1, 724), Trans(0, 117, 2, 725)], k: 1, }, - /* 311 - "InstParameterGroupList" */ + /* 315 - "InstParameterGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 721), - Trans(0, 40, 2, 722), - Trans(0, 115, 2, 722), + Trans(0, 37, 1, 726), + Trans(0, 40, 2, 727), + Trans(0, 117, 2, 727), ], k: 1, }, - /* 312 - "InstParameterItem" */ + /* 316 - "InstParameterItem" */ LookaheadDFA { - prod0: 723, + prod0: 728, transitions: &[], k: 0, }, - /* 313 - "InstParameterItemOpt" */ + /* 317 - "InstParameterItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 724), - Trans(0, 32, 2, 725), - Trans(0, 44, 2, 725), - Trans(0, 46, 2, 725), + Trans(0, 31, 1, 729), + Trans(0, 32, 2, 730), + Trans(0, 44, 2, 730), + Trans(0, 46, 2, 730), ], k: 1, }, - /* 314 - "InstParameterList" */ + /* 318 - "InstParameterList" */ LookaheadDFA { - prod0: 713, + prod0: 718, transitions: &[], k: 0, }, - /* 315 - "InstParameterListList" */ + /* 319 - "InstParameterListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -8564,23 +8632,23 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 40, 4, -1), Trans(1, 44, 11, -1), Trans(1, 46, 12, -1), - Trans(1, 115, 5, -1), - Trans(2, 5, 3, 714), - Trans(2, 41, 3, 714), - Trans(4, 5, 3, 714), - Trans(4, 37, 3, 714), - Trans(4, 40, 3, 714), - Trans(4, 115, 3, 714), - Trans(5, 5, 3, 714), - Trans(5, 31, 3, 714), - Trans(5, 32, 3, 714), - Trans(5, 44, 3, 714), - Trans(5, 46, 3, 714), - Trans(6, 37, 3, 714), - Trans(6, 40, 3, 714), - Trans(6, 44, 13, 715), - Trans(6, 46, 13, 715), - Trans(6, 115, 3, 714), + Trans(1, 117, 5, -1), + Trans(2, 5, 3, 719), + Trans(2, 41, 3, 719), + Trans(4, 5, 3, 719), + Trans(4, 37, 3, 719), + Trans(4, 40, 3, 719), + Trans(4, 117, 3, 719), + Trans(5, 5, 3, 719), + Trans(5, 31, 3, 719), + Trans(5, 32, 3, 719), + Trans(5, 44, 3, 719), + Trans(5, 46, 3, 719), + Trans(6, 37, 3, 719), + Trans(6, 40, 3, 719), + Trans(6, 44, 13, 720), + Trans(6, 46, 13, 720), + Trans(6, 117, 3, 719), Trans(7, 5, 9, -1), Trans(7, 32, 10, -1), Trans(7, 44, 11, -1), @@ -8588,122 +8656,122 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(8, 5, 14, -1), Trans(8, 42, 15, -1), Trans(8, 47, 16, -1), - Trans(9, 32, 13, 715), - Trans(9, 44, 13, 715), - Trans(9, 46, 13, 715), - Trans(10, 5, 13, 715), - Trans(10, 37, 13, 715), - Trans(10, 40, 13, 715), - Trans(10, 44, 13, 715), - Trans(10, 46, 13, 715), - Trans(10, 115, 13, 715), - Trans(11, 5, 13, 715), - Trans(11, 32, 13, 715), - Trans(11, 44, 13, 715), - Trans(11, 46, 13, 715), - Trans(12, 5, 13, 715), - Trans(12, 42, 13, 715), - Trans(12, 47, 13, 715), - Trans(14, 42, 13, 715), - Trans(14, 47, 13, 715), - Trans(15, 5, 13, 715), - Trans(15, 37, 13, 715), - Trans(15, 40, 13, 715), - Trans(15, 46, 13, 715), - Trans(15, 115, 13, 715), - Trans(16, 5, 13, 715), - Trans(16, 31, 13, 715), - Trans(16, 37, 13, 715), - Trans(16, 40, 13, 715), - Trans(16, 44, 13, 715), - Trans(16, 49, 13, 715), - Trans(16, 50, 13, 715), - Trans(16, 51, 13, 715), - Trans(16, 61, 13, 715), - Trans(16, 65, 13, 715), - Trans(16, 66, 13, 715), - Trans(16, 67, 13, 715), - Trans(16, 71, 13, 715), - Trans(16, 72, 13, 715), - Trans(16, 74, 13, 715), - Trans(16, 78, 13, 715), - Trans(16, 81, 13, 715), - Trans(16, 82, 13, 715), - Trans(16, 105, 13, 715), - Trans(16, 108, 13, 715), - Trans(16, 111, 13, 715), - Trans(16, 112, 13, 715), - Trans(16, 113, 13, 715), + Trans(9, 32, 13, 720), + Trans(9, 44, 13, 720), + Trans(9, 46, 13, 720), + Trans(10, 5, 13, 720), + Trans(10, 37, 13, 720), + Trans(10, 40, 13, 720), + Trans(10, 44, 13, 720), + Trans(10, 46, 13, 720), + Trans(10, 117, 13, 720), + Trans(11, 5, 13, 720), + Trans(11, 32, 13, 720), + Trans(11, 44, 13, 720), + Trans(11, 46, 13, 720), + Trans(12, 5, 13, 720), + Trans(12, 42, 13, 720), + Trans(12, 47, 13, 720), + Trans(14, 42, 13, 720), + Trans(14, 47, 13, 720), + Trans(15, 5, 13, 720), + Trans(15, 37, 13, 720), + Trans(15, 40, 13, 720), + Trans(15, 46, 13, 720), + Trans(15, 117, 13, 720), + Trans(16, 5, 13, 720), + Trans(16, 31, 13, 720), + Trans(16, 37, 13, 720), + Trans(16, 40, 13, 720), + Trans(16, 44, 13, 720), + Trans(16, 49, 13, 720), + Trans(16, 50, 13, 720), + Trans(16, 51, 13, 720), + Trans(16, 62, 13, 720), + Trans(16, 66, 13, 720), + Trans(16, 67, 13, 720), + Trans(16, 68, 13, 720), + Trans(16, 72, 13, 720), + Trans(16, 73, 13, 720), + Trans(16, 75, 13, 720), + Trans(16, 79, 13, 720), + Trans(16, 82, 13, 720), + Trans(16, 83, 13, 720), + Trans(16, 107, 13, 720), + Trans(16, 110, 13, 720), + Trans(16, 113, 13, 720), + Trans(16, 114, 13, 720), + Trans(16, 115, 13, 720), ], k: 3, }, - /* 316 - "InstParameterListOpt" */ + /* 320 - "InstParameterListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 1, 716), - Trans(0, 44, 2, 717), - Trans(0, 46, 2, 717), + Trans(0, 32, 1, 721), + Trans(0, 44, 2, 722), + Trans(0, 46, 2, 722), ], k: 1, }, - /* 317 - "InstParameterOpt" */ + /* 321 - "InstParameterOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 711), - Trans(0, 40, 1, 711), - Trans(0, 46, 2, 712), - Trans(0, 115, 1, 711), + Trans(0, 37, 1, 716), + Trans(0, 40, 1, 716), + Trans(0, 46, 2, 717), + Trans(0, 117, 1, 716), ], k: 1, }, - /* 318 - "InstPortGroup" */ + /* 322 - "InstPortGroup" */ LookaheadDFA { - prod0: 731, + prod0: 736, transitions: &[], k: 0, }, - /* 319 - "InstPortGroupGroup" */ + /* 323 - "InstPortGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 732), Trans(0, 115, 2, 733)], + transitions: &[Trans(0, 40, 1, 737), Trans(0, 117, 2, 738)], k: 1, }, - /* 320 - "InstPortGroupList" */ + /* 324 - "InstPortGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 734), - Trans(0, 40, 2, 735), - Trans(0, 115, 2, 735), + Trans(0, 37, 1, 739), + Trans(0, 40, 2, 740), + Trans(0, 117, 2, 740), ], k: 1, }, - /* 321 - "InstPortItem" */ + /* 325 - "InstPortItem" */ LookaheadDFA { - prod0: 736, + prod0: 741, transitions: &[], k: 0, }, - /* 322 - "InstPortItemOpt" */ + /* 326 - "InstPortItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 737), - Trans(0, 32, 2, 738), - Trans(0, 44, 2, 738), - Trans(0, 46, 2, 738), + Trans(0, 31, 1, 742), + Trans(0, 32, 2, 743), + Trans(0, 44, 2, 743), + Trans(0, 46, 2, 743), ], k: 1, }, - /* 323 - "InstPortList" */ + /* 327 - "InstPortList" */ LookaheadDFA { - prod0: 726, + prod0: 731, transitions: &[], k: 0, }, - /* 324 - "InstPortListList" */ + /* 328 - "InstPortListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -8715,259 +8783,259 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 40, 4, -1), Trans(1, 44, 11, -1), Trans(1, 46, 12, -1), - Trans(1, 115, 5, -1), - Trans(2, 5, 3, 727), - Trans(2, 41, 3, 727), - Trans(4, 5, 3, 727), - Trans(4, 37, 3, 727), - Trans(4, 40, 3, 727), - Trans(4, 115, 3, 727), - Trans(5, 5, 3, 727), - Trans(5, 31, 3, 727), - Trans(5, 32, 3, 727), - Trans(5, 44, 3, 727), - Trans(5, 46, 3, 727), - Trans(6, 37, 3, 727), - Trans(6, 40, 3, 727), - Trans(6, 44, 13, 728), - Trans(6, 46, 13, 728), - Trans(6, 115, 3, 727), + Trans(1, 117, 5, -1), + Trans(2, 5, 3, 732), + Trans(2, 41, 3, 732), + Trans(4, 5, 3, 732), + Trans(4, 37, 3, 732), + Trans(4, 40, 3, 732), + Trans(4, 117, 3, 732), + Trans(5, 5, 3, 732), + Trans(5, 31, 3, 732), + Trans(5, 32, 3, 732), + Trans(5, 44, 3, 732), + Trans(5, 46, 3, 732), + Trans(6, 37, 3, 732), + Trans(6, 40, 3, 732), + Trans(6, 44, 13, 733), + Trans(6, 46, 13, 733), + Trans(6, 117, 3, 732), Trans(7, 5, 9, -1), Trans(7, 32, 10, -1), Trans(7, 44, 11, -1), Trans(7, 46, 12, -1), Trans(8, 5, 14, -1), Trans(8, 47, 15, -1), - Trans(9, 32, 13, 728), - Trans(9, 44, 13, 728), - Trans(9, 46, 13, 728), - Trans(10, 5, 13, 728), - Trans(10, 37, 13, 728), - Trans(10, 40, 13, 728), - Trans(10, 44, 13, 728), - Trans(10, 46, 13, 728), - Trans(10, 115, 13, 728), - Trans(11, 5, 13, 728), - Trans(11, 32, 13, 728), - Trans(11, 44, 13, 728), - Trans(11, 46, 13, 728), - Trans(12, 5, 13, 728), - Trans(12, 47, 13, 728), - Trans(14, 47, 13, 728), - Trans(15, 5, 13, 728), - Trans(15, 31, 13, 728), - Trans(15, 37, 13, 728), - Trans(15, 40, 13, 728), - Trans(15, 44, 13, 728), - Trans(15, 49, 13, 728), - Trans(15, 50, 13, 728), - Trans(15, 51, 13, 728), - Trans(15, 61, 13, 728), - Trans(15, 65, 13, 728), - Trans(15, 66, 13, 728), - Trans(15, 67, 13, 728), - Trans(15, 71, 13, 728), - Trans(15, 72, 13, 728), - Trans(15, 74, 13, 728), - Trans(15, 78, 13, 728), - Trans(15, 81, 13, 728), - Trans(15, 82, 13, 728), - Trans(15, 105, 13, 728), - Trans(15, 108, 13, 728), - Trans(15, 111, 13, 728), - Trans(15, 112, 13, 728), - Trans(15, 113, 13, 728), + Trans(9, 32, 13, 733), + Trans(9, 44, 13, 733), + Trans(9, 46, 13, 733), + Trans(10, 5, 13, 733), + Trans(10, 37, 13, 733), + Trans(10, 40, 13, 733), + Trans(10, 44, 13, 733), + Trans(10, 46, 13, 733), + Trans(10, 117, 13, 733), + Trans(11, 5, 13, 733), + Trans(11, 32, 13, 733), + Trans(11, 44, 13, 733), + Trans(11, 46, 13, 733), + Trans(12, 5, 13, 733), + Trans(12, 47, 13, 733), + Trans(14, 47, 13, 733), + Trans(15, 5, 13, 733), + Trans(15, 31, 13, 733), + Trans(15, 37, 13, 733), + Trans(15, 40, 13, 733), + Trans(15, 44, 13, 733), + Trans(15, 49, 13, 733), + Trans(15, 50, 13, 733), + Trans(15, 51, 13, 733), + Trans(15, 62, 13, 733), + Trans(15, 66, 13, 733), + Trans(15, 67, 13, 733), + Trans(15, 68, 13, 733), + Trans(15, 72, 13, 733), + Trans(15, 73, 13, 733), + Trans(15, 75, 13, 733), + Trans(15, 79, 13, 733), + Trans(15, 82, 13, 733), + Trans(15, 83, 13, 733), + Trans(15, 107, 13, 733), + Trans(15, 110, 13, 733), + Trans(15, 113, 13, 733), + Trans(15, 114, 13, 733), + Trans(15, 115, 13, 733), ], k: 3, }, - /* 325 - "InstPortListOpt" */ + /* 329 - "InstPortListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 1, 729), - Trans(0, 44, 2, 730), - Trans(0, 46, 2, 730), + Trans(0, 32, 1, 734), + Trans(0, 44, 2, 735), + Trans(0, 46, 2, 735), ], k: 1, }, - /* 326 - "InstTerm" */ + /* 330 - "InstTerm" */ LookaheadDFA { - prod0: 73, + prod0: 74, transitions: &[], k: 0, }, - /* 327 - "InstToken" */ + /* 331 - "InstToken" */ LookaheadDFA { - prod0: 188, + prod0: 191, transitions: &[], k: 0, }, - /* 328 - "IntegralNumber" */ + /* 332 - "IntegralNumber" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 9, 1, 339), - Trans(0, 10, 3, 341), - Trans(0, 11, 2, 340), + Trans(0, 9, 1, 345), + Trans(0, 10, 3, 347), + Trans(0, 11, 2, 346), ], k: 1, }, - /* 329 - "Interface" */ + /* 333 - "Interface" */ LookaheadDFA { - prod0: 302, + prod0: 307, transitions: &[], k: 0, }, - /* 330 - "InterfaceDeclaration" */ + /* 334 - "InterfaceDeclaration" */ LookaheadDFA { - prod0: 880, + prod0: 890, transitions: &[], k: 0, }, - /* 331 - "InterfaceDeclarationList" */ + /* 335 - "InterfaceDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 881), - Trans(0, 37, 1, 881), - Trans(0, 40, 1, 881), - Trans(0, 44, 2, 882), - Trans(0, 61, 1, 881), - Trans(0, 65, 1, 881), - Trans(0, 66, 1, 881), - Trans(0, 67, 1, 881), - Trans(0, 71, 1, 881), - Trans(0, 72, 1, 881), - Trans(0, 74, 1, 881), - Trans(0, 81, 1, 881), - Trans(0, 82, 1, 881), - Trans(0, 85, 1, 881), - Trans(0, 105, 1, 881), - Trans(0, 108, 1, 881), - Trans(0, 111, 1, 881), - Trans(0, 113, 1, 881), + Trans(0, 31, 1, 891), + Trans(0, 37, 1, 891), + Trans(0, 40, 1, 891), + Trans(0, 44, 2, 892), + Trans(0, 62, 1, 891), + Trans(0, 66, 1, 891), + Trans(0, 67, 1, 891), + Trans(0, 68, 1, 891), + Trans(0, 72, 1, 891), + Trans(0, 73, 1, 891), + Trans(0, 75, 1, 891), + Trans(0, 82, 1, 891), + Trans(0, 83, 1, 891), + Trans(0, 86, 1, 891), + Trans(0, 107, 1, 891), + Trans(0, 110, 1, 891), + Trans(0, 113, 1, 891), + Trans(0, 115, 1, 891), ], k: 1, }, - /* 332 - "InterfaceDeclarationOpt" */ + /* 336 - "InterfaceDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 79, 2, 888), Trans(0, 92, 1, 887)], + transitions: &[Trans(0, 80, 2, 898), Trans(0, 94, 1, 897)], k: 1, }, - /* 333 - "InterfaceDeclarationOpt0" */ + /* 337 - "InterfaceDeclarationOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 885), - Trans(0, 37, 2, 886), - Trans(0, 40, 2, 886), + Trans(0, 29, 1, 895), + Trans(0, 37, 2, 896), + Trans(0, 40, 2, 896), ], k: 1, }, - /* 334 - "InterfaceDeclarationOpt1" */ + /* 338 - "InterfaceDeclarationOpt1" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 37, 1, 883), Trans(0, 40, 2, 884)], + transitions: &[Trans(0, 37, 1, 893), Trans(0, 40, 2, 894)], k: 1, }, - /* 335 - "InterfaceForDeclaration" */ + /* 339 - "InterfaceForDeclaration" */ LookaheadDFA { - prod0: 894, + prod0: 904, transitions: &[], k: 0, }, - /* 336 - "InterfaceForDeclarationOpt" */ + /* 340 - "InterfaceForDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 31, 2, 896), Trans(0, 103, 1, 895)], + transitions: &[Trans(0, 31, 2, 906), Trans(0, 105, 1, 905)], k: 1, }, - /* 337 - "InterfaceGroup" */ + /* 341 - "InterfaceGroup" */ LookaheadDFA { - prod0: 905, + prod0: 915, transitions: &[], k: 0, }, - /* 338 - "InterfaceGroupGroup" */ + /* 342 - "InterfaceGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 2, 909), - Trans(0, 40, 1, 906), - Trans(0, 61, 2, 909), - Trans(0, 65, 2, 909), - Trans(0, 66, 2, 909), - Trans(0, 67, 2, 909), - Trans(0, 71, 2, 909), - Trans(0, 72, 2, 909), - Trans(0, 74, 2, 909), - Trans(0, 81, 2, 909), - Trans(0, 82, 2, 909), - Trans(0, 85, 2, 909), - Trans(0, 105, 2, 909), - Trans(0, 108, 2, 909), - Trans(0, 111, 2, 909), - Trans(0, 113, 2, 909), + Trans(0, 31, 2, 919), + Trans(0, 40, 1, 916), + Trans(0, 62, 2, 919), + Trans(0, 66, 2, 919), + Trans(0, 67, 2, 919), + Trans(0, 68, 2, 919), + Trans(0, 72, 2, 919), + Trans(0, 73, 2, 919), + Trans(0, 75, 2, 919), + Trans(0, 82, 2, 919), + Trans(0, 83, 2, 919), + Trans(0, 86, 2, 919), + Trans(0, 107, 2, 919), + Trans(0, 110, 2, 919), + Trans(0, 113, 2, 919), + Trans(0, 115, 2, 919), ], k: 1, }, - /* 339 - "InterfaceGroupGroupList" */ + /* 343 - "InterfaceGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 907), - Trans(0, 37, 1, 907), - Trans(0, 40, 1, 907), - Trans(0, 44, 2, 908), - Trans(0, 61, 1, 907), - Trans(0, 65, 1, 907), - Trans(0, 66, 1, 907), - Trans(0, 67, 1, 907), - Trans(0, 71, 1, 907), - Trans(0, 72, 1, 907), - Trans(0, 74, 1, 907), - Trans(0, 81, 1, 907), - Trans(0, 82, 1, 907), - Trans(0, 85, 1, 907), - Trans(0, 105, 1, 907), - Trans(0, 108, 1, 907), - Trans(0, 111, 1, 907), - Trans(0, 113, 1, 907), + Trans(0, 31, 1, 917), + Trans(0, 37, 1, 917), + Trans(0, 40, 1, 917), + Trans(0, 44, 2, 918), + Trans(0, 62, 1, 917), + Trans(0, 66, 1, 917), + Trans(0, 67, 1, 917), + Trans(0, 68, 1, 917), + Trans(0, 72, 1, 917), + Trans(0, 73, 1, 917), + Trans(0, 75, 1, 917), + Trans(0, 82, 1, 917), + Trans(0, 83, 1, 917), + Trans(0, 86, 1, 917), + Trans(0, 107, 1, 917), + Trans(0, 110, 1, 917), + Trans(0, 113, 1, 917), + Trans(0, 115, 1, 917), ], k: 1, }, - /* 340 - "InterfaceGroupList" */ + /* 344 - "InterfaceGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 2, 911), - Trans(0, 37, 1, 910), - Trans(0, 40, 2, 911), - Trans(0, 61, 2, 911), - Trans(0, 65, 2, 911), - Trans(0, 66, 2, 911), - Trans(0, 67, 2, 911), - Trans(0, 71, 2, 911), - Trans(0, 72, 2, 911), - Trans(0, 74, 2, 911), - Trans(0, 81, 2, 911), - Trans(0, 82, 2, 911), - Trans(0, 85, 2, 911), - Trans(0, 105, 2, 911), - Trans(0, 108, 2, 911), - Trans(0, 111, 2, 911), - Trans(0, 113, 2, 911), + Trans(0, 31, 2, 921), + Trans(0, 37, 1, 920), + Trans(0, 40, 2, 921), + Trans(0, 62, 2, 921), + Trans(0, 66, 2, 921), + Trans(0, 67, 2, 921), + Trans(0, 68, 2, 921), + Trans(0, 72, 2, 921), + Trans(0, 73, 2, 921), + Trans(0, 75, 2, 921), + Trans(0, 82, 2, 921), + Trans(0, 83, 2, 921), + Trans(0, 86, 2, 921), + Trans(0, 107, 2, 921), + Trans(0, 110, 2, 921), + Trans(0, 113, 2, 921), + Trans(0, 115, 2, 921), ], k: 1, }, - /* 341 - "InterfaceIfDeclaration" */ + /* 345 - "InterfaceIfDeclaration" */ LookaheadDFA { - prod0: 889, + prod0: 899, transitions: &[], k: 0, }, - /* 342 - "InterfaceIfDeclarationList" */ + /* 346 - "InterfaceIfDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -8975,907 +9043,914 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 37, 6, -1), Trans(0, 40, 7, -1), Trans(0, 44, 8, -1), - Trans(0, 59, 1, -1), - Trans(0, 61, 9, -1), - Trans(0, 65, 10, -1), - Trans(0, 66, 11, -1), - Trans(0, 67, 12, -1), - Trans(0, 71, 13, -1), - Trans(0, 72, 14, -1), - Trans(0, 74, 10, -1), - Trans(0, 81, 15, -1), + Trans(0, 60, 1, -1), + Trans(0, 62, 9, -1), + Trans(0, 66, 10, -1), + Trans(0, 67, 11, -1), + Trans(0, 68, 12, -1), + Trans(0, 72, 13, -1), + Trans(0, 73, 14, -1), + Trans(0, 75, 10, -1), Trans(0, 82, 15, -1), - Trans(0, 85, 5, -1), - Trans(0, 105, 16, -1), - Trans(0, 108, 17, -1), - Trans(0, 111, 16, -1), - Trans(0, 113, 15, -1), + Trans(0, 83, 15, -1), + Trans(0, 86, 5, -1), + Trans(0, 107, 16, -1), + Trans(0, 110, 17, -1), + Trans(0, 113, 16, -1), + Trans(0, 115, 15, -1), Trans(1, 5, 4, -1), Trans(1, 31, 20, -1), - Trans(1, 40, 36, -1), - Trans(1, 71, 2, -1), - Trans(2, 5, 3, 890), - Trans(2, 6, 3, 890), - Trans(2, 7, 3, 890), - Trans(2, 8, 3, 890), - Trans(2, 9, 3, 890), - Trans(2, 10, 3, 890), - Trans(2, 11, 3, 890), - Trans(2, 18, 3, 890), - Trans(2, 24, 3, 890), - Trans(2, 25, 3, 890), - Trans(2, 26, 3, 890), - Trans(2, 27, 3, 890), - Trans(2, 39, 3, 890), - Trans(2, 40, 3, 890), - Trans(2, 42, 3, 890), - Trans(2, 54, 3, 890), - Trans(2, 71, 3, 890), - Trans(2, 77, 3, 890), - Trans(2, 84, 3, 890), - Trans(2, 87, 3, 890), - Trans(2, 89, 3, 890), - Trans(2, 106, 3, 890), - Trans(2, 114, 3, 890), - Trans(2, 115, 3, 890), - Trans(4, 31, 18, 891), - Trans(4, 40, 18, 891), - Trans(4, 71, 3, 890), - Trans(5, 5, 43, -1), - Trans(5, 115, 26, -1), - Trans(6, 5, 39, -1), + Trans(1, 40, 37, -1), + Trans(1, 72, 2, -1), + Trans(2, 5, 3, 900), + Trans(2, 6, 3, 900), + Trans(2, 7, 3, 900), + Trans(2, 8, 3, 900), + Trans(2, 9, 3, 900), + Trans(2, 10, 3, 900), + Trans(2, 11, 3, 900), + Trans(2, 18, 3, 900), + Trans(2, 24, 3, 900), + Trans(2, 25, 3, 900), + Trans(2, 26, 3, 900), + Trans(2, 27, 3, 900), + Trans(2, 39, 3, 900), + Trans(2, 40, 3, 900), + Trans(2, 42, 3, 900), + Trans(2, 54, 3, 900), + Trans(2, 72, 3, 900), + Trans(2, 78, 3, 900), + Trans(2, 85, 3, 900), + Trans(2, 88, 3, 900), + Trans(2, 90, 3, 900), + Trans(2, 108, 3, 900), + Trans(2, 116, 3, 900), + Trans(2, 117, 3, 900), + Trans(4, 31, 18, 901), + Trans(4, 40, 18, 901), + Trans(4, 72, 3, 900), + Trans(5, 5, 44, -1), + Trans(5, 117, 26, -1), + Trans(6, 5, 40, -1), Trans(6, 41, 20, -1), - Trans(7, 5, 35, -1), + Trans(7, 5, 36, -1), Trans(7, 31, 20, -1), Trans(7, 37, 21, -1), - Trans(7, 40, 36, -1), - Trans(7, 44, 36, -1), - Trans(7, 61, 20, -1), - Trans(7, 65, 26, -1), - Trans(7, 66, 20, -1), + Trans(7, 40, 37, -1), + Trans(7, 44, 37, -1), + Trans(7, 62, 20, -1), + Trans(7, 66, 26, -1), Trans(7, 67, 20, -1), - Trans(7, 71, 27, -1), - Trans(7, 72, 28, -1), - Trans(7, 74, 26, -1), - Trans(7, 81, 20, -1), + Trans(7, 68, 20, -1), + Trans(7, 72, 27, -1), + Trans(7, 73, 28, -1), + Trans(7, 75, 26, -1), Trans(7, 82, 20, -1), - Trans(7, 85, 20, -1), - Trans(7, 105, 20, -1), - Trans(7, 108, 20, -1), - Trans(7, 111, 20, -1), + Trans(7, 83, 20, -1), + Trans(7, 86, 20, -1), + Trans(7, 107, 20, -1), + Trans(7, 110, 20, -1), Trans(7, 113, 20, -1), - Trans(8, 0, 18, 891), + Trans(7, 115, 20, -1), + Trans(8, 0, 18, 901), Trans(8, 5, 19, -1), Trans(8, 31, 20, -1), Trans(8, 37, 21, -1), Trans(8, 40, 22, -1), Trans(8, 44, 23, -1), - Trans(8, 59, 24, -1), - Trans(8, 60, 25, -1), - Trans(8, 61, 20, -1), - Trans(8, 65, 26, -1), - Trans(8, 66, 20, -1), + Trans(8, 60, 24, -1), + Trans(8, 61, 25, -1), + Trans(8, 62, 20, -1), + Trans(8, 66, 26, -1), Trans(8, 67, 20, -1), - Trans(8, 71, 27, -1), - Trans(8, 72, 28, -1), - Trans(8, 73, 25, -1), - Trans(8, 74, 26, -1), - Trans(8, 79, 20, -1), - Trans(8, 81, 20, -1), + Trans(8, 68, 20, -1), + Trans(8, 72, 27, -1), + Trans(8, 73, 28, -1), + Trans(8, 74, 25, -1), + Trans(8, 75, 26, -1), + Trans(8, 80, 20, -1), Trans(8, 82, 20, -1), - Trans(8, 85, 20, -1), + Trans(8, 83, 20, -1), Trans(8, 86, 20, -1), - Trans(8, 90, 20, -1), - Trans(8, 92, 29, -1), - Trans(8, 105, 20, -1), - Trans(8, 108, 20, -1), - Trans(8, 111, 20, -1), + Trans(8, 87, 20, -1), + Trans(8, 91, 20, -1), + Trans(8, 93, 29, -1), + Trans(8, 94, 30, -1), + Trans(8, 107, 20, -1), + Trans(8, 110, 20, -1), Trans(8, 113, 20, -1), - Trans(9, 5, 43, -1), - Trans(9, 115, 44, -1), - Trans(10, 5, 37, -1), - Trans(10, 40, 38, -1), - Trans(11, 5, 43, -1), - Trans(11, 115, 45, -1), - Trans(12, 5, 43, -1), - Trans(12, 115, 46, -1), - Trans(13, 5, 30, -1), - Trans(13, 6, 31, -1), - Trans(13, 7, 31, -1), - Trans(13, 8, 31, -1), - Trans(13, 9, 31, -1), - Trans(13, 10, 31, -1), - Trans(13, 11, 31, -1), + Trans(8, 115, 20, -1), + Trans(9, 5, 44, -1), + Trans(9, 117, 45, -1), + Trans(10, 5, 38, -1), + Trans(10, 40, 39, -1), + Trans(11, 5, 44, -1), + Trans(11, 117, 46, -1), + Trans(12, 5, 44, -1), + Trans(12, 117, 47, -1), + Trans(13, 5, 31, -1), + Trans(13, 6, 32, -1), + Trans(13, 7, 32, -1), + Trans(13, 8, 32, -1), + Trans(13, 9, 32, -1), + Trans(13, 10, 32, -1), + Trans(13, 11, 32, -1), Trans(13, 18, 27, -1), Trans(13, 24, 27, -1), Trans(13, 25, 27, -1), Trans(13, 26, 27, -1), Trans(13, 27, 27, -1), - Trans(13, 39, 32, -1), + Trans(13, 39, 33, -1), Trans(13, 40, 27, -1), Trans(13, 42, 27, -1), Trans(13, 54, 27, -1), - Trans(13, 71, 27, -1), - Trans(13, 77, 27, -1), - Trans(13, 84, 31, -1), - Trans(13, 87, 31, -1), - Trans(13, 89, 27, -1), - Trans(13, 106, 26, -1), - Trans(13, 114, 33, -1), - Trans(13, 115, 34, -1), - Trans(14, 5, 40, -1), - Trans(14, 114, 41, -1), - Trans(14, 115, 42, -1), - Trans(15, 5, 43, -1), - Trans(15, 115, 47, -1), - Trans(16, 5, 43, -1), - Trans(16, 115, 48, -1), - Trans(17, 5, 43, -1), - Trans(17, 115, 49, -1), - Trans(19, 0, 18, 891), - Trans(19, 31, 18, 891), - Trans(19, 37, 18, 891), - Trans(19, 40, 18, 891), - Trans(19, 44, 18, 891), - Trans(19, 59, 18, 891), - Trans(19, 60, 18, 891), - Trans(19, 61, 18, 891), - Trans(19, 65, 18, 891), - Trans(19, 66, 18, 891), - Trans(19, 67, 18, 891), - Trans(19, 71, 18, 891), - Trans(19, 72, 18, 891), - Trans(19, 73, 18, 891), - Trans(19, 74, 18, 891), - Trans(19, 79, 18, 891), - Trans(19, 81, 18, 891), - Trans(19, 82, 18, 891), - Trans(19, 85, 18, 891), - Trans(19, 86, 18, 891), - Trans(19, 90, 18, 891), - Trans(19, 92, 18, 891), - Trans(19, 105, 18, 891), - Trans(19, 108, 18, 891), - Trans(19, 111, 18, 891), - Trans(19, 113, 18, 891), - Trans(20, 5, 18, 891), - Trans(20, 115, 18, 891), - Trans(21, 5, 18, 891), - Trans(21, 41, 18, 891), - Trans(22, 5, 18, 891), - Trans(22, 31, 18, 891), - Trans(22, 37, 18, 891), - Trans(22, 40, 18, 891), - Trans(22, 44, 18, 891), - Trans(22, 60, 18, 891), - Trans(22, 61, 18, 891), - Trans(22, 65, 18, 891), - Trans(22, 66, 18, 891), - Trans(22, 67, 18, 891), - Trans(22, 71, 18, 891), - Trans(22, 72, 18, 891), - Trans(22, 73, 18, 891), - Trans(22, 74, 18, 891), - Trans(22, 79, 18, 891), - Trans(22, 81, 18, 891), - Trans(22, 82, 18, 891), - Trans(22, 85, 18, 891), - Trans(22, 86, 18, 891), - Trans(22, 90, 18, 891), - Trans(22, 92, 18, 891), - Trans(22, 105, 18, 891), - Trans(22, 108, 18, 891), - Trans(22, 111, 18, 891), - Trans(22, 113, 18, 891), - Trans(23, 0, 18, 891), - Trans(23, 5, 18, 891), - Trans(23, 31, 18, 891), - Trans(23, 37, 18, 891), - Trans(23, 40, 18, 891), - Trans(23, 44, 18, 891), - Trans(23, 59, 18, 891), - Trans(23, 60, 18, 891), - Trans(23, 61, 18, 891), - Trans(23, 65, 18, 891), - Trans(23, 66, 18, 891), - Trans(23, 67, 18, 891), - Trans(23, 71, 18, 891), - Trans(23, 72, 18, 891), - Trans(23, 73, 18, 891), - Trans(23, 74, 18, 891), - Trans(23, 79, 18, 891), - Trans(23, 81, 18, 891), - Trans(23, 82, 18, 891), - Trans(23, 85, 18, 891), - Trans(23, 86, 18, 891), - Trans(23, 90, 18, 891), - Trans(23, 92, 18, 891), - Trans(23, 105, 18, 891), - Trans(23, 108, 18, 891), - Trans(23, 111, 18, 891), - Trans(23, 113, 18, 891), - Trans(24, 5, 18, 891), - Trans(24, 31, 18, 891), - Trans(24, 40, 18, 891), - Trans(24, 71, 18, 891), - Trans(25, 5, 18, 891), - Trans(25, 42, 18, 891), - Trans(26, 5, 18, 891), - Trans(26, 40, 18, 891), - Trans(27, 5, 18, 891), - Trans(27, 6, 18, 891), - Trans(27, 7, 18, 891), - Trans(27, 8, 18, 891), - Trans(27, 9, 18, 891), - Trans(27, 10, 18, 891), - Trans(27, 11, 18, 891), - Trans(27, 18, 18, 891), - Trans(27, 24, 18, 891), - Trans(27, 25, 18, 891), - Trans(27, 26, 18, 891), - Trans(27, 27, 18, 891), - Trans(27, 39, 18, 891), - Trans(27, 40, 18, 891), - Trans(27, 42, 18, 891), - Trans(27, 54, 18, 891), - Trans(27, 71, 18, 891), - Trans(27, 77, 18, 891), - Trans(27, 84, 18, 891), - Trans(27, 87, 18, 891), - Trans(27, 89, 18, 891), - Trans(27, 106, 18, 891), - Trans(27, 114, 18, 891), - Trans(27, 115, 18, 891), - Trans(28, 5, 18, 891), - Trans(28, 114, 18, 891), - Trans(28, 115, 18, 891), - Trans(29, 5, 18, 891), - Trans(29, 79, 18, 891), - Trans(29, 86, 18, 891), - Trans(29, 90, 18, 891), - Trans(30, 6, 18, 891), - Trans(30, 7, 18, 891), - Trans(30, 8, 18, 891), - Trans(30, 9, 18, 891), - Trans(30, 10, 18, 891), - Trans(30, 11, 18, 891), - Trans(30, 18, 18, 891), - Trans(30, 24, 18, 891), - Trans(30, 25, 18, 891), - Trans(30, 26, 18, 891), - Trans(30, 27, 18, 891), - Trans(30, 39, 18, 891), - Trans(30, 40, 18, 891), - Trans(30, 42, 18, 891), - Trans(30, 54, 18, 891), - Trans(30, 71, 18, 891), - Trans(30, 77, 18, 891), - Trans(30, 84, 18, 891), - Trans(30, 87, 18, 891), - Trans(30, 89, 18, 891), - Trans(30, 106, 18, 891), - Trans(30, 114, 18, 891), - Trans(30, 115, 18, 891), - Trans(31, 5, 18, 891), - Trans(31, 16, 18, 891), - Trans(31, 17, 18, 891), - Trans(31, 18, 18, 891), - Trans(31, 19, 18, 891), - Trans(31, 20, 18, 891), - Trans(31, 21, 18, 891), - Trans(31, 22, 18, 891), - Trans(31, 23, 18, 891), - Trans(31, 24, 18, 891), - Trans(31, 25, 18, 891), - Trans(31, 26, 18, 891), - Trans(31, 31, 18, 891), - Trans(31, 48, 18, 891), - Trans(31, 52, 18, 891), - Trans(32, 5, 18, 891), - Trans(32, 6, 18, 891), - Trans(32, 7, 18, 891), - Trans(32, 8, 18, 891), - Trans(32, 9, 18, 891), - Trans(32, 10, 18, 891), - Trans(32, 11, 18, 891), - Trans(32, 18, 18, 891), - Trans(32, 24, 18, 891), - Trans(32, 25, 18, 891), - Trans(32, 26, 18, 891), - Trans(32, 27, 18, 891), - Trans(32, 39, 18, 891), - Trans(32, 40, 18, 891), - Trans(32, 42, 18, 891), - Trans(32, 54, 18, 891), - Trans(32, 58, 18, 891), - Trans(32, 71, 18, 891), - Trans(32, 77, 18, 891), - Trans(32, 84, 18, 891), - Trans(32, 87, 18, 891), - Trans(32, 89, 18, 891), - Trans(32, 106, 18, 891), - Trans(32, 114, 18, 891), - Trans(32, 115, 18, 891), - Trans(33, 5, 18, 891), - Trans(33, 16, 18, 891), - Trans(33, 17, 18, 891), - Trans(33, 18, 18, 891), - Trans(33, 19, 18, 891), - Trans(33, 20, 18, 891), - Trans(33, 21, 18, 891), - Trans(33, 22, 18, 891), - Trans(33, 23, 18, 891), - Trans(33, 24, 18, 891), - Trans(33, 25, 18, 891), - Trans(33, 26, 18, 891), - Trans(33, 30, 18, 891), - Trans(33, 31, 18, 891), - Trans(33, 35, 18, 891), - Trans(33, 41, 18, 891), - Trans(33, 42, 18, 891), - Trans(33, 48, 18, 891), - Trans(33, 52, 18, 891), - Trans(34, 5, 18, 891), - Trans(34, 16, 18, 891), - Trans(34, 17, 18, 891), - Trans(34, 18, 18, 891), - Trans(34, 19, 18, 891), - Trans(34, 20, 18, 891), - Trans(34, 21, 18, 891), - Trans(34, 22, 18, 891), - Trans(34, 23, 18, 891), - Trans(34, 24, 18, 891), - Trans(34, 25, 18, 891), - Trans(34, 26, 18, 891), - Trans(34, 29, 18, 891), - Trans(34, 30, 18, 891), - Trans(34, 31, 18, 891), - Trans(34, 35, 18, 891), - Trans(34, 41, 18, 891), - Trans(34, 42, 18, 891), - Trans(34, 48, 18, 891), - Trans(34, 52, 18, 891), - Trans(35, 31, 18, 891), - Trans(35, 37, 18, 891), - Trans(35, 40, 18, 891), - Trans(35, 44, 18, 891), - Trans(35, 61, 18, 891), - Trans(35, 65, 18, 891), - Trans(35, 66, 18, 891), - Trans(35, 67, 18, 891), - Trans(35, 71, 18, 891), - Trans(35, 72, 18, 891), - Trans(35, 74, 18, 891), - Trans(35, 81, 18, 891), - Trans(35, 82, 18, 891), - Trans(35, 85, 18, 891), - Trans(35, 105, 18, 891), - Trans(35, 108, 18, 891), - Trans(35, 111, 18, 891), - Trans(35, 113, 18, 891), - Trans(36, 5, 18, 891), - Trans(36, 31, 18, 891), - Trans(36, 37, 18, 891), - Trans(36, 40, 18, 891), - Trans(36, 44, 18, 891), - Trans(36, 61, 18, 891), - Trans(36, 65, 18, 891), - Trans(36, 66, 18, 891), - Trans(36, 67, 18, 891), - Trans(36, 71, 18, 891), - Trans(36, 72, 18, 891), - Trans(36, 74, 18, 891), - Trans(36, 81, 18, 891), - Trans(36, 82, 18, 891), - Trans(36, 85, 18, 891), - Trans(36, 105, 18, 891), - Trans(36, 108, 18, 891), - Trans(36, 111, 18, 891), - Trans(36, 113, 18, 891), - Trans(37, 40, 18, 891), - Trans(38, 5, 18, 891), - Trans(38, 44, 18, 891), - Trans(38, 54, 18, 891), - Trans(38, 66, 18, 891), - Trans(38, 70, 18, 891), - Trans(38, 71, 18, 891), - Trans(38, 81, 18, 891), - Trans(38, 100, 18, 891), - Trans(38, 101, 18, 891), - Trans(38, 106, 18, 891), - Trans(38, 114, 18, 891), - Trans(38, 115, 18, 891), - Trans(39, 41, 18, 891), - Trans(40, 114, 18, 891), - Trans(40, 115, 18, 891), - Trans(41, 5, 18, 891), - Trans(41, 30, 18, 891), - Trans(41, 47, 18, 891), - Trans(42, 5, 18, 891), - Trans(42, 29, 18, 891), - Trans(42, 30, 18, 891), - Trans(42, 47, 18, 891), - Trans(43, 115, 18, 891), - Trans(44, 5, 18, 891), - Trans(44, 31, 18, 891), - Trans(44, 40, 18, 891), - Trans(45, 5, 18, 891), - Trans(45, 80, 18, 891), - Trans(46, 5, 18, 891), - Trans(46, 13, 18, 891), - Trans(46, 29, 18, 891), - Trans(46, 40, 18, 891), - Trans(46, 42, 18, 891), - Trans(47, 5, 18, 891), - Trans(47, 31, 18, 891), - Trans(48, 5, 18, 891), - Trans(48, 29, 18, 891), - Trans(48, 40, 18, 891), - Trans(49, 5, 18, 891), - Trans(49, 36, 18, 891), + Trans(13, 72, 27, -1), + Trans(13, 78, 27, -1), + Trans(13, 85, 32, -1), + Trans(13, 88, 32, -1), + Trans(13, 90, 27, -1), + Trans(13, 108, 26, -1), + Trans(13, 116, 34, -1), + Trans(13, 117, 35, -1), + Trans(14, 5, 41, -1), + Trans(14, 116, 42, -1), + Trans(14, 117, 43, -1), + Trans(15, 5, 44, -1), + Trans(15, 117, 48, -1), + Trans(16, 5, 44, -1), + Trans(16, 117, 49, -1), + Trans(17, 5, 44, -1), + Trans(17, 117, 50, -1), + Trans(19, 0, 18, 901), + Trans(19, 31, 18, 901), + Trans(19, 37, 18, 901), + Trans(19, 40, 18, 901), + Trans(19, 44, 18, 901), + Trans(19, 60, 18, 901), + Trans(19, 61, 18, 901), + Trans(19, 62, 18, 901), + Trans(19, 66, 18, 901), + Trans(19, 67, 18, 901), + Trans(19, 68, 18, 901), + Trans(19, 72, 18, 901), + Trans(19, 73, 18, 901), + Trans(19, 74, 18, 901), + Trans(19, 75, 18, 901), + Trans(19, 80, 18, 901), + Trans(19, 82, 18, 901), + Trans(19, 83, 18, 901), + Trans(19, 86, 18, 901), + Trans(19, 87, 18, 901), + Trans(19, 91, 18, 901), + Trans(19, 93, 18, 901), + Trans(19, 94, 18, 901), + Trans(19, 107, 18, 901), + Trans(19, 110, 18, 901), + Trans(19, 113, 18, 901), + Trans(19, 115, 18, 901), + Trans(20, 5, 18, 901), + Trans(20, 117, 18, 901), + Trans(21, 5, 18, 901), + Trans(21, 41, 18, 901), + Trans(22, 5, 18, 901), + Trans(22, 31, 18, 901), + Trans(22, 37, 18, 901), + Trans(22, 40, 18, 901), + Trans(22, 44, 18, 901), + Trans(22, 61, 18, 901), + Trans(22, 62, 18, 901), + Trans(22, 66, 18, 901), + Trans(22, 67, 18, 901), + Trans(22, 68, 18, 901), + Trans(22, 72, 18, 901), + Trans(22, 73, 18, 901), + Trans(22, 74, 18, 901), + Trans(22, 75, 18, 901), + Trans(22, 80, 18, 901), + Trans(22, 82, 18, 901), + Trans(22, 83, 18, 901), + Trans(22, 86, 18, 901), + Trans(22, 87, 18, 901), + Trans(22, 91, 18, 901), + Trans(22, 93, 18, 901), + Trans(22, 94, 18, 901), + Trans(22, 107, 18, 901), + Trans(22, 110, 18, 901), + Trans(22, 113, 18, 901), + Trans(22, 115, 18, 901), + Trans(23, 0, 18, 901), + Trans(23, 5, 18, 901), + Trans(23, 31, 18, 901), + Trans(23, 37, 18, 901), + Trans(23, 40, 18, 901), + Trans(23, 44, 18, 901), + Trans(23, 60, 18, 901), + Trans(23, 61, 18, 901), + Trans(23, 62, 18, 901), + Trans(23, 66, 18, 901), + Trans(23, 67, 18, 901), + Trans(23, 68, 18, 901), + Trans(23, 72, 18, 901), + Trans(23, 73, 18, 901), + Trans(23, 74, 18, 901), + Trans(23, 75, 18, 901), + Trans(23, 80, 18, 901), + Trans(23, 82, 18, 901), + Trans(23, 83, 18, 901), + Trans(23, 86, 18, 901), + Trans(23, 87, 18, 901), + Trans(23, 91, 18, 901), + Trans(23, 93, 18, 901), + Trans(23, 94, 18, 901), + Trans(23, 107, 18, 901), + Trans(23, 110, 18, 901), + Trans(23, 113, 18, 901), + Trans(23, 115, 18, 901), + Trans(24, 5, 18, 901), + Trans(24, 31, 18, 901), + Trans(24, 40, 18, 901), + Trans(24, 72, 18, 901), + Trans(25, 5, 18, 901), + Trans(25, 42, 18, 901), + Trans(26, 5, 18, 901), + Trans(26, 40, 18, 901), + Trans(27, 5, 18, 901), + Trans(27, 6, 18, 901), + Trans(27, 7, 18, 901), + Trans(27, 8, 18, 901), + Trans(27, 9, 18, 901), + Trans(27, 10, 18, 901), + Trans(27, 11, 18, 901), + Trans(27, 18, 18, 901), + Trans(27, 24, 18, 901), + Trans(27, 25, 18, 901), + Trans(27, 26, 18, 901), + Trans(27, 27, 18, 901), + Trans(27, 39, 18, 901), + Trans(27, 40, 18, 901), + Trans(27, 42, 18, 901), + Trans(27, 54, 18, 901), + Trans(27, 72, 18, 901), + Trans(27, 78, 18, 901), + Trans(27, 85, 18, 901), + Trans(27, 88, 18, 901), + Trans(27, 90, 18, 901), + Trans(27, 108, 18, 901), + Trans(27, 116, 18, 901), + Trans(27, 117, 18, 901), + Trans(28, 5, 18, 901), + Trans(28, 116, 18, 901), + Trans(28, 117, 18, 901), + Trans(29, 5, 18, 901), + Trans(29, 87, 18, 901), + Trans(30, 5, 18, 901), + Trans(30, 80, 18, 901), + Trans(30, 87, 18, 901), + Trans(30, 91, 18, 901), + Trans(30, 93, 18, 901), + Trans(31, 6, 18, 901), + Trans(31, 7, 18, 901), + Trans(31, 8, 18, 901), + Trans(31, 9, 18, 901), + Trans(31, 10, 18, 901), + Trans(31, 11, 18, 901), + Trans(31, 18, 18, 901), + Trans(31, 24, 18, 901), + Trans(31, 25, 18, 901), + Trans(31, 26, 18, 901), + Trans(31, 27, 18, 901), + Trans(31, 39, 18, 901), + Trans(31, 40, 18, 901), + Trans(31, 42, 18, 901), + Trans(31, 54, 18, 901), + Trans(31, 72, 18, 901), + Trans(31, 78, 18, 901), + Trans(31, 85, 18, 901), + Trans(31, 88, 18, 901), + Trans(31, 90, 18, 901), + Trans(31, 108, 18, 901), + Trans(31, 116, 18, 901), + Trans(31, 117, 18, 901), + Trans(32, 5, 18, 901), + Trans(32, 16, 18, 901), + Trans(32, 17, 18, 901), + Trans(32, 18, 18, 901), + Trans(32, 19, 18, 901), + Trans(32, 20, 18, 901), + Trans(32, 21, 18, 901), + Trans(32, 22, 18, 901), + Trans(32, 23, 18, 901), + Trans(32, 24, 18, 901), + Trans(32, 25, 18, 901), + Trans(32, 26, 18, 901), + Trans(32, 31, 18, 901), + Trans(32, 48, 18, 901), + Trans(32, 52, 18, 901), + Trans(33, 5, 18, 901), + Trans(33, 6, 18, 901), + Trans(33, 7, 18, 901), + Trans(33, 8, 18, 901), + Trans(33, 9, 18, 901), + Trans(33, 10, 18, 901), + Trans(33, 11, 18, 901), + Trans(33, 18, 18, 901), + Trans(33, 24, 18, 901), + Trans(33, 25, 18, 901), + Trans(33, 26, 18, 901), + Trans(33, 27, 18, 901), + Trans(33, 39, 18, 901), + Trans(33, 40, 18, 901), + Trans(33, 42, 18, 901), + Trans(33, 54, 18, 901), + Trans(33, 59, 18, 901), + Trans(33, 72, 18, 901), + Trans(33, 78, 18, 901), + Trans(33, 85, 18, 901), + Trans(33, 88, 18, 901), + Trans(33, 90, 18, 901), + Trans(33, 108, 18, 901), + Trans(33, 116, 18, 901), + Trans(33, 117, 18, 901), + Trans(34, 5, 18, 901), + Trans(34, 16, 18, 901), + Trans(34, 17, 18, 901), + Trans(34, 18, 18, 901), + Trans(34, 19, 18, 901), + Trans(34, 20, 18, 901), + Trans(34, 21, 18, 901), + Trans(34, 22, 18, 901), + Trans(34, 23, 18, 901), + Trans(34, 24, 18, 901), + Trans(34, 25, 18, 901), + Trans(34, 26, 18, 901), + Trans(34, 30, 18, 901), + Trans(34, 31, 18, 901), + Trans(34, 35, 18, 901), + Trans(34, 41, 18, 901), + Trans(34, 42, 18, 901), + Trans(34, 48, 18, 901), + Trans(34, 52, 18, 901), + Trans(35, 5, 18, 901), + Trans(35, 16, 18, 901), + Trans(35, 17, 18, 901), + Trans(35, 18, 18, 901), + Trans(35, 19, 18, 901), + Trans(35, 20, 18, 901), + Trans(35, 21, 18, 901), + Trans(35, 22, 18, 901), + Trans(35, 23, 18, 901), + Trans(35, 24, 18, 901), + Trans(35, 25, 18, 901), + Trans(35, 26, 18, 901), + Trans(35, 29, 18, 901), + Trans(35, 30, 18, 901), + Trans(35, 31, 18, 901), + Trans(35, 35, 18, 901), + Trans(35, 41, 18, 901), + Trans(35, 42, 18, 901), + Trans(35, 48, 18, 901), + Trans(35, 52, 18, 901), + Trans(36, 31, 18, 901), + Trans(36, 37, 18, 901), + Trans(36, 40, 18, 901), + Trans(36, 44, 18, 901), + Trans(36, 62, 18, 901), + Trans(36, 66, 18, 901), + Trans(36, 67, 18, 901), + Trans(36, 68, 18, 901), + Trans(36, 72, 18, 901), + Trans(36, 73, 18, 901), + Trans(36, 75, 18, 901), + Trans(36, 82, 18, 901), + Trans(36, 83, 18, 901), + Trans(36, 86, 18, 901), + Trans(36, 107, 18, 901), + Trans(36, 110, 18, 901), + Trans(36, 113, 18, 901), + Trans(36, 115, 18, 901), + Trans(37, 5, 18, 901), + Trans(37, 31, 18, 901), + Trans(37, 37, 18, 901), + Trans(37, 40, 18, 901), + Trans(37, 44, 18, 901), + Trans(37, 62, 18, 901), + Trans(37, 66, 18, 901), + Trans(37, 67, 18, 901), + Trans(37, 68, 18, 901), + Trans(37, 72, 18, 901), + Trans(37, 73, 18, 901), + Trans(37, 75, 18, 901), + Trans(37, 82, 18, 901), + Trans(37, 83, 18, 901), + Trans(37, 86, 18, 901), + Trans(37, 107, 18, 901), + Trans(37, 110, 18, 901), + Trans(37, 113, 18, 901), + Trans(37, 115, 18, 901), + Trans(38, 40, 18, 901), + Trans(39, 5, 18, 901), + Trans(39, 44, 18, 901), + Trans(39, 54, 18, 901), + Trans(39, 67, 18, 901), + Trans(39, 71, 18, 901), + Trans(39, 72, 18, 901), + Trans(39, 82, 18, 901), + Trans(39, 102, 18, 901), + Trans(39, 103, 18, 901), + Trans(39, 108, 18, 901), + Trans(39, 116, 18, 901), + Trans(39, 117, 18, 901), + Trans(40, 41, 18, 901), + Trans(41, 116, 18, 901), + Trans(41, 117, 18, 901), + Trans(42, 5, 18, 901), + Trans(42, 30, 18, 901), + Trans(42, 47, 18, 901), + Trans(43, 5, 18, 901), + Trans(43, 29, 18, 901), + Trans(43, 30, 18, 901), + Trans(43, 47, 18, 901), + Trans(44, 117, 18, 901), + Trans(45, 5, 18, 901), + Trans(45, 31, 18, 901), + Trans(45, 40, 18, 901), + Trans(46, 5, 18, 901), + Trans(46, 81, 18, 901), + Trans(47, 5, 18, 901), + Trans(47, 13, 18, 901), + Trans(47, 29, 18, 901), + Trans(47, 40, 18, 901), + Trans(47, 42, 18, 901), + Trans(48, 5, 18, 901), + Trans(48, 31, 18, 901), + Trans(49, 5, 18, 901), + Trans(49, 29, 18, 901), + Trans(49, 40, 18, 901), + Trans(50, 5, 18, 901), + Trans(50, 36, 18, 901), ], k: 3, }, - /* 343 - "InterfaceIfDeclarationOpt" */ + /* 347 - "InterfaceIfDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 2, 893), - Trans(0, 37, 2, 893), - Trans(0, 40, 2, 893), - Trans(0, 44, 2, 893), - Trans(0, 59, 1, 892), - Trans(0, 61, 2, 893), - Trans(0, 65, 2, 893), - Trans(0, 66, 2, 893), - Trans(0, 67, 2, 893), - Trans(0, 71, 2, 893), - Trans(0, 72, 2, 893), - Trans(0, 74, 2, 893), - Trans(0, 81, 2, 893), - Trans(0, 82, 2, 893), - Trans(0, 85, 2, 893), - Trans(0, 105, 2, 893), - Trans(0, 108, 2, 893), - Trans(0, 111, 2, 893), - Trans(0, 113, 2, 893), + Trans(0, 31, 2, 903), + Trans(0, 37, 2, 903), + Trans(0, 40, 2, 903), + Trans(0, 44, 2, 903), + Trans(0, 60, 1, 902), + Trans(0, 62, 2, 903), + Trans(0, 66, 2, 903), + Trans(0, 67, 2, 903), + Trans(0, 68, 2, 903), + Trans(0, 72, 2, 903), + Trans(0, 73, 2, 903), + Trans(0, 75, 2, 903), + Trans(0, 82, 2, 903), + Trans(0, 83, 2, 903), + Trans(0, 86, 2, 903), + Trans(0, 107, 2, 903), + Trans(0, 110, 2, 903), + Trans(0, 113, 2, 903), + Trans(0, 115, 2, 903), ], k: 1, }, - /* 344 - "InterfaceItem" */ + /* 348 - "InterfaceItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 10, 921), - Trans(0, 61, 8, 919), - Trans(0, 65, 14, 925), - Trans(0, 66, 6, 917), - Trans(0, 67, 11, 922), - Trans(0, 71, 5, 916), - Trans(0, 72, 12, 923), - Trans(0, 74, 13, 924), - Trans(0, 81, 1, 912), - Trans(0, 82, 3, 914), - Trans(0, 85, 4, 915), - Trans(0, 105, 9, 920), - Trans(0, 108, 7, 918), - Trans(0, 111, 9, 920), - Trans(0, 113, 2, 913), + Trans(0, 31, 10, 931), + Trans(0, 62, 8, 929), + Trans(0, 66, 14, 935), + Trans(0, 67, 6, 927), + Trans(0, 68, 11, 932), + Trans(0, 72, 5, 926), + Trans(0, 73, 12, 933), + Trans(0, 75, 13, 934), + Trans(0, 82, 1, 922), + Trans(0, 83, 3, 924), + Trans(0, 86, 4, 925), + Trans(0, 107, 9, 930), + Trans(0, 110, 7, 928), + Trans(0, 113, 9, 930), + Trans(0, 115, 2, 923), ], k: 1, }, - /* 345 - "InterfaceNamedBlock" */ + /* 349 - "InterfaceNamedBlock" */ LookaheadDFA { - prod0: 897, + prod0: 907, transitions: &[], k: 0, }, - /* 346 - "InterfaceNamedBlockList" */ + /* 350 - "InterfaceNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 898), - Trans(0, 37, 1, 898), - Trans(0, 40, 1, 898), - Trans(0, 44, 2, 899), - Trans(0, 61, 1, 898), - Trans(0, 65, 1, 898), - Trans(0, 66, 1, 898), - Trans(0, 67, 1, 898), - Trans(0, 71, 1, 898), - Trans(0, 72, 1, 898), - Trans(0, 74, 1, 898), - Trans(0, 81, 1, 898), - Trans(0, 82, 1, 898), - Trans(0, 85, 1, 898), - Trans(0, 105, 1, 898), - Trans(0, 108, 1, 898), - Trans(0, 111, 1, 898), - Trans(0, 113, 1, 898), + Trans(0, 31, 1, 908), + Trans(0, 37, 1, 908), + Trans(0, 40, 1, 908), + Trans(0, 44, 2, 909), + Trans(0, 62, 1, 908), + Trans(0, 66, 1, 908), + Trans(0, 67, 1, 908), + Trans(0, 68, 1, 908), + Trans(0, 72, 1, 908), + Trans(0, 73, 1, 908), + Trans(0, 75, 1, 908), + Trans(0, 82, 1, 908), + Trans(0, 83, 1, 908), + Trans(0, 86, 1, 908), + Trans(0, 107, 1, 908), + Trans(0, 110, 1, 908), + Trans(0, 113, 1, 908), + Trans(0, 115, 1, 908), ], k: 1, }, - /* 347 - "InterfaceOptionalNamedBlock" */ + /* 351 - "InterfaceOptionalNamedBlock" */ LookaheadDFA { - prod0: 900, + prod0: 910, transitions: &[], k: 0, }, - /* 348 - "InterfaceOptionalNamedBlockList" */ + /* 352 - "InterfaceOptionalNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 901), - Trans(0, 37, 1, 901), - Trans(0, 40, 1, 901), - Trans(0, 44, 2, 902), - Trans(0, 61, 1, 901), - Trans(0, 65, 1, 901), - Trans(0, 66, 1, 901), - Trans(0, 67, 1, 901), - Trans(0, 71, 1, 901), - Trans(0, 72, 1, 901), - Trans(0, 74, 1, 901), - Trans(0, 81, 1, 901), - Trans(0, 82, 1, 901), - Trans(0, 85, 1, 901), - Trans(0, 105, 1, 901), - Trans(0, 108, 1, 901), - Trans(0, 111, 1, 901), - Trans(0, 113, 1, 901), + Trans(0, 31, 1, 911), + Trans(0, 37, 1, 911), + Trans(0, 40, 1, 911), + Trans(0, 44, 2, 912), + Trans(0, 62, 1, 911), + Trans(0, 66, 1, 911), + Trans(0, 67, 1, 911), + Trans(0, 68, 1, 911), + Trans(0, 72, 1, 911), + Trans(0, 73, 1, 911), + Trans(0, 75, 1, 911), + Trans(0, 82, 1, 911), + Trans(0, 83, 1, 911), + Trans(0, 86, 1, 911), + Trans(0, 107, 1, 911), + Trans(0, 110, 1, 911), + Trans(0, 113, 1, 911), + Trans(0, 115, 1, 911), ], k: 1, }, - /* 349 - "InterfaceOptionalNamedBlockOpt" */ + /* 353 - "InterfaceOptionalNamedBlockOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 31, 1, 903), Trans(0, 40, 2, 904)], + transitions: &[Trans(0, 31, 1, 913), Trans(0, 40, 2, 914)], k: 1, }, - /* 350 - "InterfaceTerm" */ + /* 354 - "InterfaceTerm" */ LookaheadDFA { - prod0: 74, + prod0: 75, transitions: &[], k: 0, }, - /* 351 - "InterfaceToken" */ + /* 355 - "InterfaceToken" */ LookaheadDFA { - prod0: 189, + prod0: 192, transitions: &[], k: 0, }, - /* 352 - "LAngle" */ + /* 356 - "LAngle" */ LookaheadDFA { - prod0: 257, + prod0: 261, transitions: &[], k: 0, }, - /* 353 - "LAngleTerm" */ + /* 357 - "LAngleTerm" */ LookaheadDFA { prod0: 33, transitions: &[], k: 0, }, - /* 354 - "LAngleToken" */ + /* 358 - "LAngleToken" */ LookaheadDFA { - prod0: 146, + prod0: 148, transitions: &[], k: 0, }, - /* 355 - "LBrace" */ + /* 359 - "LBrace" */ LookaheadDFA { - prod0: 258, + prod0: 262, transitions: &[], k: 0, }, - /* 356 - "LBraceTerm" */ + /* 360 - "LBraceTerm" */ LookaheadDFA { prod0: 35, transitions: &[], k: 0, }, - /* 357 - "LBraceToken" */ + /* 361 - "LBraceToken" */ LookaheadDFA { - prod0: 147, + prod0: 149, transitions: &[], k: 0, }, - /* 358 - "LBracket" */ + /* 362 - "LBracket" */ LookaheadDFA { - prod0: 259, + prod0: 263, transitions: &[], k: 0, }, - /* 359 - "LBracketTerm" */ + /* 363 - "LBracketTerm" */ LookaheadDFA { prod0: 36, transitions: &[], k: 0, }, - /* 360 - "LBracketToken" */ + /* 364 - "LBracketToken" */ LookaheadDFA { - prod0: 148, + prod0: 150, transitions: &[], k: 0, }, - /* 361 - "LParen" */ + /* 365 - "LParen" */ LookaheadDFA { - prod0: 260, + prod0: 264, transitions: &[], k: 0, }, - /* 362 - "LParenTerm" */ + /* 366 - "LParenTerm" */ LookaheadDFA { prod0: 37, transitions: &[], k: 0, }, - /* 363 - "LParenToken" */ + /* 367 - "LParenToken" */ LookaheadDFA { - prod0: 149, + prod0: 151, transitions: &[], k: 0, }, - /* 364 - "Let" */ + /* 368 - "Let" */ LookaheadDFA { - prod0: 303, + prod0: 308, transitions: &[], k: 0, }, - /* 365 - "LetDeclaration" */ + /* 369 - "LetDeclaration" */ LookaheadDFA { - prod0: 627, + prod0: 632, transitions: &[], k: 0, }, - /* 366 - "LetDeclarationOpt" */ + /* 370 - "LetDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 28, 1, 628), - Trans(0, 53, 2, 629), - Trans(0, 55, 2, 629), - Trans(0, 56, 2, 629), - Trans(0, 57, 2, 629), - Trans(0, 63, 2, 629), - Trans(0, 64, 2, 629), - Trans(0, 68, 2, 629), - Trans(0, 69, 2, 629), - Trans(0, 83, 2, 629), - Trans(0, 95, 2, 629), - Trans(0, 96, 2, 629), - Trans(0, 97, 2, 629), - Trans(0, 98, 2, 629), - Trans(0, 99, 2, 629), - Trans(0, 102, 2, 629), - Trans(0, 104, 2, 629), - Trans(0, 107, 2, 629), - Trans(0, 109, 2, 629), - Trans(0, 110, 2, 629), - Trans(0, 114, 2, 629), - Trans(0, 115, 2, 629), + Trans(0, 28, 1, 633), + Trans(0, 53, 2, 634), + Trans(0, 55, 2, 634), + Trans(0, 56, 2, 634), + Trans(0, 57, 2, 634), + Trans(0, 64, 2, 634), + Trans(0, 65, 2, 634), + Trans(0, 69, 2, 634), + Trans(0, 70, 2, 634), + Trans(0, 84, 2, 634), + Trans(0, 97, 2, 634), + Trans(0, 98, 2, 634), + Trans(0, 99, 2, 634), + Trans(0, 100, 2, 634), + Trans(0, 101, 2, 634), + Trans(0, 104, 2, 634), + Trans(0, 106, 2, 634), + Trans(0, 109, 2, 634), + Trans(0, 111, 2, 634), + Trans(0, 112, 2, 634), + Trans(0, 116, 2, 634), + Trans(0, 117, 2, 634), ], k: 1, }, - /* 367 - "LetStatement" */ + /* 371 - "LetStatement" */ LookaheadDFA { - prod0: 553, + prod0: 558, transitions: &[], k: 0, }, - /* 368 - "LetStatementOpt" */ + /* 372 - "LetStatementOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 28, 1, 554), - Trans(0, 53, 2, 555), - Trans(0, 55, 2, 555), - Trans(0, 56, 2, 555), - Trans(0, 57, 2, 555), - Trans(0, 63, 2, 555), - Trans(0, 64, 2, 555), - Trans(0, 68, 2, 555), - Trans(0, 69, 2, 555), - Trans(0, 83, 2, 555), - Trans(0, 95, 2, 555), - Trans(0, 96, 2, 555), - Trans(0, 97, 2, 555), - Trans(0, 98, 2, 555), - Trans(0, 99, 2, 555), - Trans(0, 102, 2, 555), - Trans(0, 104, 2, 555), - Trans(0, 107, 2, 555), - Trans(0, 109, 2, 555), - Trans(0, 110, 2, 555), - Trans(0, 114, 2, 555), - Trans(0, 115, 2, 555), + Trans(0, 28, 1, 559), + Trans(0, 53, 2, 560), + Trans(0, 55, 2, 560), + Trans(0, 56, 2, 560), + Trans(0, 57, 2, 560), + Trans(0, 64, 2, 560), + Trans(0, 65, 2, 560), + Trans(0, 69, 2, 560), + Trans(0, 70, 2, 560), + Trans(0, 84, 2, 560), + Trans(0, 97, 2, 560), + Trans(0, 98, 2, 560), + Trans(0, 99, 2, 560), + Trans(0, 100, 2, 560), + Trans(0, 101, 2, 560), + Trans(0, 104, 2, 560), + Trans(0, 106, 2, 560), + Trans(0, 109, 2, 560), + Trans(0, 111, 2, 560), + Trans(0, 112, 2, 560), + Trans(0, 116, 2, 560), + Trans(0, 117, 2, 560), ], k: 1, }, - /* 369 - "LetTerm" */ + /* 373 - "LetTerm" */ LookaheadDFA { - prod0: 76, + prod0: 77, transitions: &[], k: 0, }, - /* 370 - "LetToken" */ + /* 374 - "LetToken" */ LookaheadDFA { - prod0: 191, + prod0: 194, transitions: &[], k: 0, }, - /* 371 - "Local" */ + /* 375 - "Local" */ LookaheadDFA { - prod0: 304, + prod0: 309, transitions: &[], k: 0, }, - /* 372 - "LocalDeclaration" */ + /* 376 - "LocalDeclaration" */ LookaheadDFA { - prod0: 633, + prod0: 638, transitions: &[], k: 0, }, - /* 373 - "LocalDeclarationGroup" */ + /* 377 - "LocalDeclarationGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 53, 1, 634), - Trans(0, 55, 1, 634), - Trans(0, 56, 1, 634), - Trans(0, 57, 1, 634), - Trans(0, 63, 1, 634), - Trans(0, 64, 1, 634), - Trans(0, 68, 1, 634), - Trans(0, 69, 1, 634), - Trans(0, 83, 1, 634), - Trans(0, 95, 1, 634), - Trans(0, 96, 1, 634), - Trans(0, 97, 1, 634), - Trans(0, 98, 1, 634), - Trans(0, 99, 1, 634), - Trans(0, 102, 1, 634), - Trans(0, 104, 1, 634), - Trans(0, 107, 1, 634), - Trans(0, 108, 2, 635), - Trans(0, 109, 1, 634), - Trans(0, 110, 1, 634), - Trans(0, 114, 1, 634), - Trans(0, 115, 1, 634), + Trans(0, 53, 1, 639), + Trans(0, 55, 1, 639), + Trans(0, 56, 1, 639), + Trans(0, 57, 1, 639), + Trans(0, 64, 1, 639), + Trans(0, 65, 1, 639), + Trans(0, 69, 1, 639), + Trans(0, 70, 1, 639), + Trans(0, 84, 1, 639), + Trans(0, 97, 1, 639), + Trans(0, 98, 1, 639), + Trans(0, 99, 1, 639), + Trans(0, 100, 1, 639), + Trans(0, 101, 1, 639), + Trans(0, 104, 1, 639), + Trans(0, 106, 1, 639), + Trans(0, 109, 1, 639), + Trans(0, 110, 2, 640), + Trans(0, 111, 1, 639), + Trans(0, 112, 1, 639), + Trans(0, 116, 1, 639), + Trans(0, 117, 1, 639), ], k: 1, }, - /* 374 - "LocalTerm" */ + /* 378 - "LocalTerm" */ LookaheadDFA { - prod0: 77, + prod0: 78, transitions: &[], k: 0, }, - /* 375 - "LocalToken" */ + /* 379 - "LocalToken" */ LookaheadDFA { - prod0: 192, + prod0: 195, transitions: &[], k: 0, }, - /* 376 - "Logic" */ + /* 380 - "Logic" */ LookaheadDFA { - prod0: 305, + prod0: 310, transitions: &[], k: 0, }, - /* 377 - "LogicTerm" */ + /* 381 - "LogicTerm" */ LookaheadDFA { - prod0: 78, + prod0: 79, transitions: &[], k: 0, }, - /* 378 - "LogicToken" */ + /* 382 - "LogicToken" */ LookaheadDFA { - prod0: 193, + prod0: 196, transitions: &[], k: 0, }, - /* 379 - "Lsb" */ + /* 383 - "Lsb" */ LookaheadDFA { - prod0: 306, + prod0: 311, transitions: &[], k: 0, }, - /* 380 - "LsbTerm" */ + /* 384 - "LsbTerm" */ LookaheadDFA { - prod0: 79, + prod0: 80, transitions: &[], k: 0, }, - /* 381 - "LsbToken" */ + /* 385 - "LsbToken" */ LookaheadDFA { - prod0: 194, + prod0: 197, transitions: &[], k: 0, }, - /* 382 - "MinusColon" */ + /* 386 - "MinusColon" */ LookaheadDFA { - prod0: 261, + prod0: 265, transitions: &[], k: 0, }, - /* 383 - "MinusColonTerm" */ + /* 387 - "MinusColonTerm" */ LookaheadDFA { prod0: 7, transitions: &[], k: 0, }, - /* 384 - "MinusColonToken" */ + /* 388 - "MinusColonToken" */ LookaheadDFA { - prod0: 150, + prod0: 152, transitions: &[], k: 0, }, - /* 385 - "MinusGT" */ + /* 389 - "MinusGT" */ LookaheadDFA { - prod0: 262, + prod0: 266, transitions: &[], k: 0, }, - /* 386 - "MinusGTTerm" */ + /* 390 - "MinusGTTerm" */ LookaheadDFA { prod0: 8, transitions: &[], k: 0, }, - /* 387 - "MinusGTToken" */ + /* 391 - "MinusGTToken" */ LookaheadDFA { - prod0: 151, + prod0: 153, transitions: &[], k: 0, }, - /* 388 - "Modport" */ + /* 392 - "Modport" */ LookaheadDFA { - prod0: 307, + prod0: 312, transitions: &[], k: 0, }, - /* 389 - "ModportDeclaration" */ + /* 393 - "ModportDeclaration" */ LookaheadDFA { - prod0: 651, + prod0: 656, transitions: &[], k: 0, }, - /* 390 - "ModportGroup" */ + /* 394 - "ModportGroup" */ LookaheadDFA { - prod0: 657, + prod0: 662, transitions: &[], k: 0, }, - /* 391 - "ModportGroupGroup" */ + /* 395 - "ModportGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 658), Trans(0, 115, 2, 659)], + transitions: &[Trans(0, 40, 1, 663), Trans(0, 117, 2, 664)], k: 1, }, - /* 392 - "ModportGroupList" */ + /* 396 - "ModportGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 660), - Trans(0, 40, 2, 661), - Trans(0, 115, 2, 661), + Trans(0, 37, 1, 665), + Trans(0, 40, 2, 666), + Trans(0, 117, 2, 666), ], k: 1, }, - /* 393 - "ModportItem" */ + /* 397 - "ModportItem" */ LookaheadDFA { - prod0: 662, + prod0: 667, transitions: &[], k: 0, }, - /* 394 - "ModportList" */ + /* 398 - "ModportList" */ LookaheadDFA { - prod0: 652, + prod0: 657, transitions: &[], k: 0, }, - /* 395 - "ModportListList" */ + /* 399 - "ModportListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -9885,367 +9960,380 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 37, 2, -1), Trans(1, 40, 4, -1), Trans(1, 44, 18, -1), - Trans(1, 115, 5, -1), - Trans(2, 5, 3, 653), - Trans(2, 41, 3, 653), - Trans(4, 5, 3, 653), - Trans(4, 37, 3, 653), - Trans(4, 40, 3, 653), - Trans(4, 115, 3, 653), - Trans(5, 5, 3, 653), - Trans(5, 31, 3, 653), - Trans(6, 37, 3, 653), - Trans(6, 40, 3, 653), - Trans(6, 44, 17, 654), - Trans(6, 115, 3, 653), + Trans(1, 117, 5, -1), + Trans(2, 5, 3, 658), + Trans(2, 41, 3, 658), + Trans(4, 5, 3, 658), + Trans(4, 37, 3, 658), + Trans(4, 40, 3, 658), + Trans(4, 117, 3, 658), + Trans(5, 5, 3, 658), + Trans(5, 31, 3, 658), + Trans(6, 37, 3, 658), + Trans(6, 40, 3, 658), + Trans(6, 44, 17, 659), + Trans(6, 117, 3, 658), Trans(7, 5, 8, -1), Trans(7, 31, 9, -1), Trans(7, 32, 10, -1), Trans(7, 37, 11, -1), Trans(7, 40, 12, -1), Trans(7, 44, 13, -1), - Trans(7, 61, 9, -1), - Trans(7, 65, 14, -1), - Trans(7, 66, 9, -1), + Trans(7, 62, 9, -1), + Trans(7, 66, 14, -1), Trans(7, 67, 9, -1), - Trans(7, 71, 15, -1), - Trans(7, 72, 16, -1), - Trans(7, 74, 14, -1), - Trans(7, 81, 9, -1), + Trans(7, 68, 9, -1), + Trans(7, 72, 15, -1), + Trans(7, 73, 16, -1), + Trans(7, 75, 14, -1), Trans(7, 82, 9, -1), - Trans(7, 85, 9, -1), - Trans(7, 105, 9, -1), - Trans(7, 108, 9, -1), - Trans(7, 111, 9, -1), + Trans(7, 83, 9, -1), + Trans(7, 86, 9, -1), + Trans(7, 107, 9, -1), + Trans(7, 110, 9, -1), Trans(7, 113, 9, -1), - Trans(8, 31, 17, 654), - Trans(8, 32, 17, 654), - Trans(8, 37, 17, 654), - Trans(8, 40, 17, 654), - Trans(8, 44, 17, 654), - Trans(8, 61, 17, 654), - Trans(8, 65, 17, 654), - Trans(8, 66, 17, 654), - Trans(8, 67, 17, 654), - Trans(8, 71, 17, 654), - Trans(8, 72, 17, 654), - Trans(8, 74, 17, 654), - Trans(8, 81, 17, 654), - Trans(8, 82, 17, 654), - Trans(8, 85, 17, 654), - Trans(8, 105, 17, 654), - Trans(8, 108, 17, 654), - Trans(8, 111, 17, 654), - Trans(8, 113, 17, 654), - Trans(9, 5, 17, 654), - Trans(9, 115, 17, 654), - Trans(10, 5, 17, 654), - Trans(10, 37, 17, 654), - Trans(10, 40, 17, 654), - Trans(10, 44, 17, 654), - Trans(10, 115, 17, 654), - Trans(11, 5, 17, 654), - Trans(11, 41, 17, 654), - Trans(12, 5, 17, 654), - Trans(12, 31, 17, 654), - Trans(12, 37, 17, 654), - Trans(12, 40, 17, 654), - Trans(12, 44, 17, 654), - Trans(12, 61, 17, 654), - Trans(12, 65, 17, 654), - Trans(12, 66, 17, 654), - Trans(12, 67, 17, 654), - Trans(12, 71, 17, 654), - Trans(12, 72, 17, 654), - Trans(12, 74, 17, 654), - Trans(12, 81, 17, 654), - Trans(12, 82, 17, 654), - Trans(12, 85, 17, 654), - Trans(12, 105, 17, 654), - Trans(12, 108, 17, 654), - Trans(12, 111, 17, 654), - Trans(12, 113, 17, 654), - Trans(13, 0, 17, 654), - Trans(13, 5, 17, 654), - Trans(13, 31, 17, 654), - Trans(13, 32, 17, 654), - Trans(13, 37, 17, 654), - Trans(13, 40, 17, 654), - Trans(13, 44, 17, 654), - Trans(13, 59, 17, 654), - Trans(13, 60, 17, 654), - Trans(13, 61, 17, 654), - Trans(13, 65, 17, 654), - Trans(13, 66, 17, 654), - Trans(13, 67, 17, 654), - Trans(13, 71, 17, 654), - Trans(13, 72, 17, 654), - Trans(13, 73, 17, 654), - Trans(13, 74, 17, 654), - Trans(13, 79, 17, 654), - Trans(13, 81, 17, 654), - Trans(13, 82, 17, 654), - Trans(13, 85, 17, 654), - Trans(13, 86, 17, 654), - Trans(13, 90, 17, 654), - Trans(13, 92, 17, 654), - Trans(13, 105, 17, 654), - Trans(13, 108, 17, 654), - Trans(13, 111, 17, 654), - Trans(13, 113, 17, 654), - Trans(14, 5, 17, 654), - Trans(14, 40, 17, 654), - Trans(15, 5, 17, 654), - Trans(15, 6, 17, 654), - Trans(15, 7, 17, 654), - Trans(15, 8, 17, 654), - Trans(15, 9, 17, 654), - Trans(15, 10, 17, 654), - Trans(15, 11, 17, 654), - Trans(15, 18, 17, 654), - Trans(15, 24, 17, 654), - Trans(15, 25, 17, 654), - Trans(15, 26, 17, 654), - Trans(15, 27, 17, 654), - Trans(15, 39, 17, 654), - Trans(15, 40, 17, 654), - Trans(15, 42, 17, 654), - Trans(15, 54, 17, 654), - Trans(15, 71, 17, 654), - Trans(15, 77, 17, 654), - Trans(15, 84, 17, 654), - Trans(15, 87, 17, 654), - Trans(15, 89, 17, 654), - Trans(15, 106, 17, 654), - Trans(15, 114, 17, 654), - Trans(15, 115, 17, 654), - Trans(16, 5, 17, 654), - Trans(16, 114, 17, 654), - Trans(16, 115, 17, 654), - Trans(18, 5, 17, 654), - Trans(18, 31, 17, 654), - Trans(18, 32, 17, 654), - Trans(18, 37, 17, 654), - Trans(18, 40, 17, 654), - Trans(18, 44, 17, 654), - Trans(18, 61, 17, 654), - Trans(18, 65, 17, 654), - Trans(18, 66, 17, 654), - Trans(18, 67, 17, 654), - Trans(18, 71, 17, 654), - Trans(18, 72, 17, 654), - Trans(18, 74, 17, 654), - Trans(18, 81, 17, 654), - Trans(18, 82, 17, 654), - Trans(18, 85, 17, 654), - Trans(18, 105, 17, 654), - Trans(18, 108, 17, 654), - Trans(18, 111, 17, 654), - Trans(18, 113, 17, 654), + Trans(7, 115, 9, -1), + Trans(8, 31, 17, 659), + Trans(8, 32, 17, 659), + Trans(8, 37, 17, 659), + Trans(8, 40, 17, 659), + Trans(8, 44, 17, 659), + Trans(8, 62, 17, 659), + Trans(8, 66, 17, 659), + Trans(8, 67, 17, 659), + Trans(8, 68, 17, 659), + Trans(8, 72, 17, 659), + Trans(8, 73, 17, 659), + Trans(8, 75, 17, 659), + Trans(8, 82, 17, 659), + Trans(8, 83, 17, 659), + Trans(8, 86, 17, 659), + Trans(8, 107, 17, 659), + Trans(8, 110, 17, 659), + Trans(8, 113, 17, 659), + Trans(8, 115, 17, 659), + Trans(9, 5, 17, 659), + Trans(9, 117, 17, 659), + Trans(10, 5, 17, 659), + Trans(10, 37, 17, 659), + Trans(10, 40, 17, 659), + Trans(10, 44, 17, 659), + Trans(10, 117, 17, 659), + Trans(11, 5, 17, 659), + Trans(11, 41, 17, 659), + Trans(12, 5, 17, 659), + Trans(12, 31, 17, 659), + Trans(12, 37, 17, 659), + Trans(12, 40, 17, 659), + Trans(12, 44, 17, 659), + Trans(12, 62, 17, 659), + Trans(12, 66, 17, 659), + Trans(12, 67, 17, 659), + Trans(12, 68, 17, 659), + Trans(12, 72, 17, 659), + Trans(12, 73, 17, 659), + Trans(12, 75, 17, 659), + Trans(12, 82, 17, 659), + Trans(12, 83, 17, 659), + Trans(12, 86, 17, 659), + Trans(12, 107, 17, 659), + Trans(12, 110, 17, 659), + Trans(12, 113, 17, 659), + Trans(12, 115, 17, 659), + Trans(13, 0, 17, 659), + Trans(13, 5, 17, 659), + Trans(13, 31, 17, 659), + Trans(13, 32, 17, 659), + Trans(13, 37, 17, 659), + Trans(13, 40, 17, 659), + Trans(13, 44, 17, 659), + Trans(13, 60, 17, 659), + Trans(13, 61, 17, 659), + Trans(13, 62, 17, 659), + Trans(13, 66, 17, 659), + Trans(13, 67, 17, 659), + Trans(13, 68, 17, 659), + Trans(13, 72, 17, 659), + Trans(13, 73, 17, 659), + Trans(13, 74, 17, 659), + Trans(13, 75, 17, 659), + Trans(13, 80, 17, 659), + Trans(13, 82, 17, 659), + Trans(13, 83, 17, 659), + Trans(13, 86, 17, 659), + Trans(13, 87, 17, 659), + Trans(13, 91, 17, 659), + Trans(13, 93, 17, 659), + Trans(13, 94, 17, 659), + Trans(13, 107, 17, 659), + Trans(13, 110, 17, 659), + Trans(13, 113, 17, 659), + Trans(13, 115, 17, 659), + Trans(14, 5, 17, 659), + Trans(14, 40, 17, 659), + Trans(15, 5, 17, 659), + Trans(15, 6, 17, 659), + Trans(15, 7, 17, 659), + Trans(15, 8, 17, 659), + Trans(15, 9, 17, 659), + Trans(15, 10, 17, 659), + Trans(15, 11, 17, 659), + Trans(15, 18, 17, 659), + Trans(15, 24, 17, 659), + Trans(15, 25, 17, 659), + Trans(15, 26, 17, 659), + Trans(15, 27, 17, 659), + Trans(15, 39, 17, 659), + Trans(15, 40, 17, 659), + Trans(15, 42, 17, 659), + Trans(15, 54, 17, 659), + Trans(15, 72, 17, 659), + Trans(15, 78, 17, 659), + Trans(15, 85, 17, 659), + Trans(15, 88, 17, 659), + Trans(15, 90, 17, 659), + Trans(15, 108, 17, 659), + Trans(15, 116, 17, 659), + Trans(15, 117, 17, 659), + Trans(16, 5, 17, 659), + Trans(16, 116, 17, 659), + Trans(16, 117, 17, 659), + Trans(18, 5, 17, 659), + Trans(18, 31, 17, 659), + Trans(18, 32, 17, 659), + Trans(18, 37, 17, 659), + Trans(18, 40, 17, 659), + Trans(18, 44, 17, 659), + Trans(18, 62, 17, 659), + Trans(18, 66, 17, 659), + Trans(18, 67, 17, 659), + Trans(18, 68, 17, 659), + Trans(18, 72, 17, 659), + Trans(18, 73, 17, 659), + Trans(18, 75, 17, 659), + Trans(18, 82, 17, 659), + Trans(18, 83, 17, 659), + Trans(18, 86, 17, 659), + Trans(18, 107, 17, 659), + Trans(18, 110, 17, 659), + Trans(18, 113, 17, 659), + Trans(18, 115, 17, 659), ], k: 3, }, - /* 396 - "ModportListOpt" */ + /* 400 - "ModportListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 655), Trans(0, 44, 2, 656)], + transitions: &[Trans(0, 32, 1, 660), Trans(0, 44, 2, 661)], k: 1, }, - /* 397 - "ModportTerm" */ + /* 401 - "ModportTerm" */ LookaheadDFA { - prod0: 80, + prod0: 81, transitions: &[], k: 0, }, - /* 398 - "ModportToken" */ + /* 402 - "ModportToken" */ LookaheadDFA { - prod0: 195, + prod0: 198, transitions: &[], k: 0, }, - /* 399 - "Module" */ + /* 403 - "Module" */ LookaheadDFA { - prod0: 308, + prod0: 313, transitions: &[], k: 0, }, - /* 400 - "ModuleDeclaration" */ + /* 404 - "ModuleDeclaration" */ LookaheadDFA { - prod0: 828, + prod0: 836, transitions: &[], k: 0, }, - /* 401 - "ModuleDeclarationList" */ + /* 405 - "ModuleDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 829), - Trans(0, 37, 1, 829), - Trans(0, 40, 1, 829), - Trans(0, 44, 2, 830), - Trans(0, 49, 1, 829), - Trans(0, 50, 1, 829), - Trans(0, 51, 1, 829), - Trans(0, 61, 1, 829), - Trans(0, 65, 1, 829), - Trans(0, 66, 1, 829), - Trans(0, 67, 1, 829), - Trans(0, 71, 1, 829), - Trans(0, 72, 1, 829), - Trans(0, 74, 1, 829), - Trans(0, 78, 1, 829), - Trans(0, 81, 1, 829), - Trans(0, 82, 1, 829), - Trans(0, 105, 1, 829), - Trans(0, 108, 1, 829), - Trans(0, 111, 1, 829), - Trans(0, 112, 1, 829), - Trans(0, 113, 1, 829), + Trans(0, 31, 1, 837), + Trans(0, 37, 1, 837), + Trans(0, 40, 1, 837), + Trans(0, 44, 2, 838), + Trans(0, 49, 1, 837), + Trans(0, 50, 1, 837), + Trans(0, 51, 1, 837), + Trans(0, 62, 1, 837), + Trans(0, 66, 1, 837), + Trans(0, 67, 1, 837), + Trans(0, 68, 1, 837), + Trans(0, 72, 1, 837), + Trans(0, 73, 1, 837), + Trans(0, 75, 1, 837), + Trans(0, 79, 1, 837), + Trans(0, 82, 1, 837), + Trans(0, 83, 1, 837), + Trans(0, 107, 1, 837), + Trans(0, 110, 1, 837), + Trans(0, 113, 1, 837), + Trans(0, 114, 1, 837), + Trans(0, 115, 1, 837), ], k: 1, }, - /* 402 - "ModuleDeclarationOpt" */ + /* 406 - "ModuleDeclarationOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 87, 2, 848), Trans(0, 94, 1, 847)], + k: 1, + }, + /* 407 - "ModuleDeclarationOpt0" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 86, 2, 838), Trans(0, 92, 1, 837)], + transitions: &[ + Trans(0, 29, 1, 845), + Trans(0, 37, 2, 846), + Trans(0, 40, 2, 846), + Trans(0, 42, 2, 846), + Trans(0, 67, 2, 846), + ], k: 1, }, - /* 403 - "ModuleDeclarationOpt0" */ + /* 408 - "ModuleDeclarationOpt1" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 835), - Trans(0, 37, 2, 836), - Trans(0, 40, 2, 836), - Trans(0, 42, 2, 836), + Trans(0, 37, 2, 844), + Trans(0, 40, 2, 844), + Trans(0, 42, 2, 844), + Trans(0, 67, 1, 843), ], k: 1, }, - /* 404 - "ModuleDeclarationOpt1" */ + /* 409 - "ModuleDeclarationOpt2" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 833), - Trans(0, 40, 2, 834), - Trans(0, 42, 2, 834), + Trans(0, 37, 1, 841), + Trans(0, 40, 2, 842), + Trans(0, 42, 2, 842), ], k: 1, }, - /* 405 - "ModuleDeclarationOpt2" */ + /* 410 - "ModuleDeclarationOpt3" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 2, 832), Trans(0, 42, 1, 831)], + transitions: &[Trans(0, 40, 2, 840), Trans(0, 42, 1, 839)], k: 1, }, - /* 406 - "ModuleForDeclaration" */ + /* 411 - "ModuleForDeclaration" */ LookaheadDFA { - prod0: 844, + prod0: 854, transitions: &[], k: 0, }, - /* 407 - "ModuleForDeclarationOpt" */ + /* 412 - "ModuleForDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 31, 2, 846), Trans(0, 103, 1, 845)], + transitions: &[Trans(0, 31, 2, 856), Trans(0, 105, 1, 855)], k: 1, }, - /* 408 - "ModuleGroup" */ + /* 413 - "ModuleGroup" */ LookaheadDFA { - prod0: 855, + prod0: 865, transitions: &[], k: 0, }, - /* 409 - "ModuleGroupGroup" */ + /* 414 - "ModuleGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 2, 859), - Trans(0, 40, 1, 856), - Trans(0, 49, 2, 859), - Trans(0, 50, 2, 859), - Trans(0, 51, 2, 859), - Trans(0, 61, 2, 859), - Trans(0, 65, 2, 859), - Trans(0, 66, 2, 859), - Trans(0, 67, 2, 859), - Trans(0, 71, 2, 859), - Trans(0, 72, 2, 859), - Trans(0, 74, 2, 859), - Trans(0, 78, 2, 859), - Trans(0, 81, 2, 859), - Trans(0, 82, 2, 859), - Trans(0, 105, 2, 859), - Trans(0, 108, 2, 859), - Trans(0, 111, 2, 859), - Trans(0, 112, 2, 859), - Trans(0, 113, 2, 859), + Trans(0, 31, 2, 869), + Trans(0, 40, 1, 866), + Trans(0, 49, 2, 869), + Trans(0, 50, 2, 869), + Trans(0, 51, 2, 869), + Trans(0, 62, 2, 869), + Trans(0, 66, 2, 869), + Trans(0, 67, 2, 869), + Trans(0, 68, 2, 869), + Trans(0, 72, 2, 869), + Trans(0, 73, 2, 869), + Trans(0, 75, 2, 869), + Trans(0, 79, 2, 869), + Trans(0, 82, 2, 869), + Trans(0, 83, 2, 869), + Trans(0, 107, 2, 869), + Trans(0, 110, 2, 869), + Trans(0, 113, 2, 869), + Trans(0, 114, 2, 869), + Trans(0, 115, 2, 869), ], k: 1, }, - /* 410 - "ModuleGroupGroupList" */ + /* 415 - "ModuleGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 857), - Trans(0, 37, 1, 857), - Trans(0, 40, 1, 857), - Trans(0, 44, 2, 858), - Trans(0, 49, 1, 857), - Trans(0, 50, 1, 857), - Trans(0, 51, 1, 857), - Trans(0, 61, 1, 857), - Trans(0, 65, 1, 857), - Trans(0, 66, 1, 857), - Trans(0, 67, 1, 857), - Trans(0, 71, 1, 857), - Trans(0, 72, 1, 857), - Trans(0, 74, 1, 857), - Trans(0, 78, 1, 857), - Trans(0, 81, 1, 857), - Trans(0, 82, 1, 857), - Trans(0, 105, 1, 857), - Trans(0, 108, 1, 857), - Trans(0, 111, 1, 857), - Trans(0, 112, 1, 857), - Trans(0, 113, 1, 857), + Trans(0, 31, 1, 867), + Trans(0, 37, 1, 867), + Trans(0, 40, 1, 867), + Trans(0, 44, 2, 868), + Trans(0, 49, 1, 867), + Trans(0, 50, 1, 867), + Trans(0, 51, 1, 867), + Trans(0, 62, 1, 867), + Trans(0, 66, 1, 867), + Trans(0, 67, 1, 867), + Trans(0, 68, 1, 867), + Trans(0, 72, 1, 867), + Trans(0, 73, 1, 867), + Trans(0, 75, 1, 867), + Trans(0, 79, 1, 867), + Trans(0, 82, 1, 867), + Trans(0, 83, 1, 867), + Trans(0, 107, 1, 867), + Trans(0, 110, 1, 867), + Trans(0, 113, 1, 867), + Trans(0, 114, 1, 867), + Trans(0, 115, 1, 867), ], k: 1, }, - /* 411 - "ModuleGroupList" */ + /* 416 - "ModuleGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 2, 861), - Trans(0, 37, 1, 860), - Trans(0, 40, 2, 861), - Trans(0, 49, 2, 861), - Trans(0, 50, 2, 861), - Trans(0, 51, 2, 861), - Trans(0, 61, 2, 861), - Trans(0, 65, 2, 861), - Trans(0, 66, 2, 861), - Trans(0, 67, 2, 861), - Trans(0, 71, 2, 861), - Trans(0, 72, 2, 861), - Trans(0, 74, 2, 861), - Trans(0, 78, 2, 861), - Trans(0, 81, 2, 861), - Trans(0, 82, 2, 861), - Trans(0, 105, 2, 861), - Trans(0, 108, 2, 861), - Trans(0, 111, 2, 861), - Trans(0, 112, 2, 861), - Trans(0, 113, 2, 861), + Trans(0, 31, 2, 871), + Trans(0, 37, 1, 870), + Trans(0, 40, 2, 871), + Trans(0, 49, 2, 871), + Trans(0, 50, 2, 871), + Trans(0, 51, 2, 871), + Trans(0, 62, 2, 871), + Trans(0, 66, 2, 871), + Trans(0, 67, 2, 871), + Trans(0, 68, 2, 871), + Trans(0, 72, 2, 871), + Trans(0, 73, 2, 871), + Trans(0, 75, 2, 871), + Trans(0, 79, 2, 871), + Trans(0, 82, 2, 871), + Trans(0, 83, 2, 871), + Trans(0, 107, 2, 871), + Trans(0, 110, 2, 871), + Trans(0, 113, 2, 871), + Trans(0, 114, 2, 871), + Trans(0, 115, 2, 871), ], k: 1, }, - /* 412 - "ModuleIfDeclaration" */ + /* 417 - "ModuleIfDeclaration" */ LookaheadDFA { - prod0: 839, + prod0: 849, transitions: &[], k: 0, }, - /* 413 - "ModuleIfDeclarationList" */ + /* 418 - "ModuleIfDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -10256,81 +10344,81 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 49, 9, -1), Trans(0, 50, 10, -1), Trans(0, 51, 11, -1), - Trans(0, 59, 1, -1), - Trans(0, 61, 12, -1), - Trans(0, 65, 9, -1), - Trans(0, 66, 13, -1), - Trans(0, 67, 14, -1), - Trans(0, 71, 15, -1), - Trans(0, 72, 16, -1), - Trans(0, 74, 9, -1), - Trans(0, 78, 17, -1), - Trans(0, 81, 17, -1), + Trans(0, 60, 1, -1), + Trans(0, 62, 12, -1), + Trans(0, 66, 9, -1), + Trans(0, 67, 13, -1), + Trans(0, 68, 14, -1), + Trans(0, 72, 15, -1), + Trans(0, 73, 16, -1), + Trans(0, 75, 9, -1), + Trans(0, 79, 17, -1), Trans(0, 82, 17, -1), - Trans(0, 105, 18, -1), - Trans(0, 108, 19, -1), - Trans(0, 111, 18, -1), - Trans(0, 112, 20, -1), - Trans(0, 113, 17, -1), + Trans(0, 83, 17, -1), + Trans(0, 107, 18, -1), + Trans(0, 110, 19, -1), + Trans(0, 113, 18, -1), + Trans(0, 114, 20, -1), + Trans(0, 115, 17, -1), Trans(1, 5, 4, -1), Trans(1, 31, 23, -1), - Trans(1, 40, 40, -1), - Trans(1, 71, 2, -1), - Trans(2, 5, 3, 840), - Trans(2, 6, 3, 840), - Trans(2, 7, 3, 840), - Trans(2, 8, 3, 840), - Trans(2, 9, 3, 840), - Trans(2, 10, 3, 840), - Trans(2, 11, 3, 840), - Trans(2, 18, 3, 840), - Trans(2, 24, 3, 840), - Trans(2, 25, 3, 840), - Trans(2, 26, 3, 840), - Trans(2, 27, 3, 840), - Trans(2, 39, 3, 840), - Trans(2, 40, 3, 840), - Trans(2, 42, 3, 840), - Trans(2, 54, 3, 840), - Trans(2, 71, 3, 840), - Trans(2, 77, 3, 840), - Trans(2, 84, 3, 840), - Trans(2, 87, 3, 840), - Trans(2, 89, 3, 840), - Trans(2, 106, 3, 840), - Trans(2, 114, 3, 840), - Trans(2, 115, 3, 840), - Trans(4, 31, 21, 841), - Trans(4, 40, 21, 841), - Trans(4, 71, 3, 840), - Trans(5, 5, 49, -1), - Trans(5, 115, 27, -1), - Trans(6, 5, 44, -1), + Trans(1, 40, 41, -1), + Trans(1, 72, 2, -1), + Trans(2, 5, 3, 850), + Trans(2, 6, 3, 850), + Trans(2, 7, 3, 850), + Trans(2, 8, 3, 850), + Trans(2, 9, 3, 850), + Trans(2, 10, 3, 850), + Trans(2, 11, 3, 850), + Trans(2, 18, 3, 850), + Trans(2, 24, 3, 850), + Trans(2, 25, 3, 850), + Trans(2, 26, 3, 850), + Trans(2, 27, 3, 850), + Trans(2, 39, 3, 850), + Trans(2, 40, 3, 850), + Trans(2, 42, 3, 850), + Trans(2, 54, 3, 850), + Trans(2, 72, 3, 850), + Trans(2, 78, 3, 850), + Trans(2, 85, 3, 850), + Trans(2, 88, 3, 850), + Trans(2, 90, 3, 850), + Trans(2, 108, 3, 850), + Trans(2, 116, 3, 850), + Trans(2, 117, 3, 850), + Trans(4, 31, 21, 851), + Trans(4, 40, 21, 851), + Trans(4, 72, 3, 850), + Trans(5, 5, 50, -1), + Trans(5, 117, 27, -1), + Trans(6, 5, 45, -1), Trans(6, 41, 23, -1), - Trans(7, 5, 39, -1), + Trans(7, 5, 40, -1), Trans(7, 31, 23, -1), Trans(7, 37, 24, -1), - Trans(7, 40, 40, -1), - Trans(7, 44, 40, -1), + Trans(7, 40, 41, -1), + Trans(7, 44, 41, -1), Trans(7, 49, 27, -1), Trans(7, 50, 28, -1), Trans(7, 51, 23, -1), - Trans(7, 61, 23, -1), - Trans(7, 65, 27, -1), - Trans(7, 66, 23, -1), + Trans(7, 62, 23, -1), + Trans(7, 66, 27, -1), Trans(7, 67, 23, -1), - Trans(7, 71, 31, -1), - Trans(7, 72, 32, -1), - Trans(7, 74, 27, -1), - Trans(7, 78, 23, -1), - Trans(7, 81, 23, -1), + Trans(7, 68, 23, -1), + Trans(7, 72, 31, -1), + Trans(7, 73, 32, -1), + Trans(7, 75, 27, -1), + Trans(7, 79, 23, -1), Trans(7, 82, 23, -1), - Trans(7, 105, 23, -1), - Trans(7, 108, 23, -1), - Trans(7, 111, 23, -1), - Trans(7, 112, 30, -1), + Trans(7, 83, 23, -1), + Trans(7, 107, 23, -1), + Trans(7, 110, 23, -1), Trans(7, 113, 23, -1), - Trans(8, 0, 21, 841), + Trans(7, 114, 30, -1), + Trans(7, 115, 23, -1), + Trans(8, 0, 21, 851), Trans(8, 5, 22, -1), Trans(8, 31, 23, -1), Trans(8, 37, 24, -1), @@ -10339,1057 +10427,1064 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(8, 49, 27, -1), Trans(8, 50, 28, -1), Trans(8, 51, 23, -1), - Trans(8, 59, 29, -1), - Trans(8, 60, 30, -1), - Trans(8, 61, 23, -1), - Trans(8, 65, 27, -1), - Trans(8, 66, 23, -1), + Trans(8, 60, 29, -1), + Trans(8, 61, 30, -1), + Trans(8, 62, 23, -1), + Trans(8, 66, 27, -1), Trans(8, 67, 23, -1), - Trans(8, 71, 31, -1), - Trans(8, 72, 32, -1), - Trans(8, 73, 30, -1), - Trans(8, 74, 27, -1), - Trans(8, 78, 23, -1), + Trans(8, 68, 23, -1), + Trans(8, 72, 31, -1), + Trans(8, 73, 32, -1), + Trans(8, 74, 30, -1), + Trans(8, 75, 27, -1), Trans(8, 79, 23, -1), - Trans(8, 81, 23, -1), + Trans(8, 80, 23, -1), Trans(8, 82, 23, -1), - Trans(8, 86, 23, -1), - Trans(8, 90, 23, -1), - Trans(8, 92, 33, -1), - Trans(8, 105, 23, -1), - Trans(8, 108, 23, -1), - Trans(8, 111, 23, -1), - Trans(8, 112, 30, -1), + Trans(8, 83, 23, -1), + Trans(8, 87, 23, -1), + Trans(8, 91, 23, -1), + Trans(8, 93, 33, -1), + Trans(8, 94, 34, -1), + Trans(8, 107, 23, -1), + Trans(8, 110, 23, -1), Trans(8, 113, 23, -1), - Trans(9, 5, 41, -1), - Trans(9, 40, 42, -1), - Trans(10, 5, 43, -1), - Trans(10, 40, 42, -1), + Trans(8, 114, 30, -1), + Trans(8, 115, 23, -1), + Trans(9, 5, 42, -1), + Trans(9, 40, 43, -1), + Trans(10, 5, 44, -1), + Trans(10, 40, 43, -1), Trans(10, 42, 23, -1), - Trans(11, 5, 49, -1), - Trans(11, 115, 50, -1), - Trans(12, 5, 49, -1), - Trans(12, 115, 51, -1), - Trans(13, 5, 49, -1), - Trans(13, 115, 52, -1), - Trans(14, 5, 49, -1), - Trans(14, 115, 53, -1), - Trans(15, 5, 34, -1), - Trans(15, 6, 35, -1), - Trans(15, 7, 35, -1), - Trans(15, 8, 35, -1), - Trans(15, 9, 35, -1), - Trans(15, 10, 35, -1), - Trans(15, 11, 35, -1), + Trans(11, 5, 50, -1), + Trans(11, 117, 51, -1), + Trans(12, 5, 50, -1), + Trans(12, 117, 52, -1), + Trans(13, 5, 50, -1), + Trans(13, 117, 53, -1), + Trans(14, 5, 50, -1), + Trans(14, 117, 54, -1), + Trans(15, 5, 35, -1), + Trans(15, 6, 36, -1), + Trans(15, 7, 36, -1), + Trans(15, 8, 36, -1), + Trans(15, 9, 36, -1), + Trans(15, 10, 36, -1), + Trans(15, 11, 36, -1), Trans(15, 18, 31, -1), Trans(15, 24, 31, -1), Trans(15, 25, 31, -1), Trans(15, 26, 31, -1), Trans(15, 27, 31, -1), - Trans(15, 39, 36, -1), + Trans(15, 39, 37, -1), Trans(15, 40, 31, -1), Trans(15, 42, 31, -1), Trans(15, 54, 31, -1), - Trans(15, 71, 31, -1), - Trans(15, 77, 31, -1), - Trans(15, 84, 35, -1), - Trans(15, 87, 35, -1), - Trans(15, 89, 31, -1), - Trans(15, 106, 27, -1), - Trans(15, 114, 37, -1), - Trans(15, 115, 38, -1), - Trans(16, 5, 46, -1), - Trans(16, 114, 47, -1), - Trans(16, 115, 48, -1), - Trans(17, 5, 49, -1), - Trans(17, 115, 54, -1), - Trans(18, 5, 49, -1), - Trans(18, 115, 55, -1), - Trans(19, 5, 49, -1), - Trans(19, 115, 56, -1), - Trans(20, 5, 45, -1), + Trans(15, 72, 31, -1), + Trans(15, 78, 31, -1), + Trans(15, 85, 36, -1), + Trans(15, 88, 36, -1), + Trans(15, 90, 31, -1), + Trans(15, 108, 27, -1), + Trans(15, 116, 38, -1), + Trans(15, 117, 39, -1), + Trans(16, 5, 47, -1), + Trans(16, 116, 48, -1), + Trans(16, 117, 49, -1), + Trans(17, 5, 50, -1), + Trans(17, 117, 55, -1), + Trans(18, 5, 50, -1), + Trans(18, 117, 56, -1), + Trans(19, 5, 50, -1), + Trans(19, 117, 57, -1), + Trans(20, 5, 46, -1), Trans(20, 42, 23, -1), - Trans(22, 0, 21, 841), - Trans(22, 31, 21, 841), - Trans(22, 37, 21, 841), - Trans(22, 40, 21, 841), - Trans(22, 44, 21, 841), - Trans(22, 49, 21, 841), - Trans(22, 50, 21, 841), - Trans(22, 51, 21, 841), - Trans(22, 59, 21, 841), - Trans(22, 60, 21, 841), - Trans(22, 61, 21, 841), - Trans(22, 65, 21, 841), - Trans(22, 66, 21, 841), - Trans(22, 67, 21, 841), - Trans(22, 71, 21, 841), - Trans(22, 72, 21, 841), - Trans(22, 73, 21, 841), - Trans(22, 74, 21, 841), - Trans(22, 78, 21, 841), - Trans(22, 79, 21, 841), - Trans(22, 81, 21, 841), - Trans(22, 82, 21, 841), - Trans(22, 86, 21, 841), - Trans(22, 90, 21, 841), - Trans(22, 92, 21, 841), - Trans(22, 105, 21, 841), - Trans(22, 108, 21, 841), - Trans(22, 111, 21, 841), - Trans(22, 112, 21, 841), - Trans(22, 113, 21, 841), - Trans(23, 5, 21, 841), - Trans(23, 115, 21, 841), - Trans(24, 5, 21, 841), - Trans(24, 41, 21, 841), - Trans(25, 5, 21, 841), - Trans(25, 31, 21, 841), - Trans(25, 37, 21, 841), - Trans(25, 40, 21, 841), - Trans(25, 44, 21, 841), - Trans(25, 49, 21, 841), - Trans(25, 50, 21, 841), - Trans(25, 51, 21, 841), - Trans(25, 60, 21, 841), - Trans(25, 61, 21, 841), - Trans(25, 65, 21, 841), - Trans(25, 66, 21, 841), - Trans(25, 67, 21, 841), - Trans(25, 71, 21, 841), - Trans(25, 72, 21, 841), - Trans(25, 73, 21, 841), - Trans(25, 74, 21, 841), - Trans(25, 78, 21, 841), - Trans(25, 79, 21, 841), - Trans(25, 81, 21, 841), - Trans(25, 82, 21, 841), - Trans(25, 86, 21, 841), - Trans(25, 90, 21, 841), - Trans(25, 92, 21, 841), - Trans(25, 105, 21, 841), - Trans(25, 108, 21, 841), - Trans(25, 111, 21, 841), - Trans(25, 112, 21, 841), - Trans(25, 113, 21, 841), - Trans(26, 0, 21, 841), - Trans(26, 5, 21, 841), - Trans(26, 31, 21, 841), - Trans(26, 37, 21, 841), - Trans(26, 40, 21, 841), - Trans(26, 44, 21, 841), - Trans(26, 49, 21, 841), - Trans(26, 50, 21, 841), - Trans(26, 51, 21, 841), - Trans(26, 59, 21, 841), - Trans(26, 60, 21, 841), - Trans(26, 61, 21, 841), - Trans(26, 65, 21, 841), - Trans(26, 66, 21, 841), - Trans(26, 67, 21, 841), - Trans(26, 71, 21, 841), - Trans(26, 72, 21, 841), - Trans(26, 73, 21, 841), - Trans(26, 74, 21, 841), - Trans(26, 78, 21, 841), - Trans(26, 79, 21, 841), - Trans(26, 81, 21, 841), - Trans(26, 82, 21, 841), - Trans(26, 86, 21, 841), - Trans(26, 90, 21, 841), - Trans(26, 92, 21, 841), - Trans(26, 105, 21, 841), - Trans(26, 108, 21, 841), - Trans(26, 111, 21, 841), - Trans(26, 112, 21, 841), - Trans(26, 113, 21, 841), - Trans(27, 5, 21, 841), - Trans(27, 40, 21, 841), - Trans(28, 5, 21, 841), - Trans(28, 40, 21, 841), - Trans(28, 42, 21, 841), - Trans(29, 5, 21, 841), - Trans(29, 31, 21, 841), - Trans(29, 40, 21, 841), - Trans(29, 71, 21, 841), - Trans(30, 5, 21, 841), - Trans(30, 42, 21, 841), - Trans(31, 5, 21, 841), - Trans(31, 6, 21, 841), - Trans(31, 7, 21, 841), - Trans(31, 8, 21, 841), - Trans(31, 9, 21, 841), - Trans(31, 10, 21, 841), - Trans(31, 11, 21, 841), - Trans(31, 18, 21, 841), - Trans(31, 24, 21, 841), - Trans(31, 25, 21, 841), - Trans(31, 26, 21, 841), - Trans(31, 27, 21, 841), - Trans(31, 39, 21, 841), - Trans(31, 40, 21, 841), - Trans(31, 42, 21, 841), - Trans(31, 54, 21, 841), - Trans(31, 71, 21, 841), - Trans(31, 77, 21, 841), - Trans(31, 84, 21, 841), - Trans(31, 87, 21, 841), - Trans(31, 89, 21, 841), - Trans(31, 106, 21, 841), - Trans(31, 114, 21, 841), - Trans(31, 115, 21, 841), - Trans(32, 5, 21, 841), - Trans(32, 114, 21, 841), - Trans(32, 115, 21, 841), - Trans(33, 5, 21, 841), - Trans(33, 79, 21, 841), - Trans(33, 86, 21, 841), - Trans(33, 90, 21, 841), - Trans(34, 6, 21, 841), - Trans(34, 7, 21, 841), - Trans(34, 8, 21, 841), - Trans(34, 9, 21, 841), - Trans(34, 10, 21, 841), - Trans(34, 11, 21, 841), - Trans(34, 18, 21, 841), - Trans(34, 24, 21, 841), - Trans(34, 25, 21, 841), - Trans(34, 26, 21, 841), - Trans(34, 27, 21, 841), - Trans(34, 39, 21, 841), - Trans(34, 40, 21, 841), - Trans(34, 42, 21, 841), - Trans(34, 54, 21, 841), - Trans(34, 71, 21, 841), - Trans(34, 77, 21, 841), - Trans(34, 84, 21, 841), - Trans(34, 87, 21, 841), - Trans(34, 89, 21, 841), - Trans(34, 106, 21, 841), - Trans(34, 114, 21, 841), - Trans(34, 115, 21, 841), - Trans(35, 5, 21, 841), - Trans(35, 16, 21, 841), - Trans(35, 17, 21, 841), - Trans(35, 18, 21, 841), - Trans(35, 19, 21, 841), - Trans(35, 20, 21, 841), - Trans(35, 21, 21, 841), - Trans(35, 22, 21, 841), - Trans(35, 23, 21, 841), - Trans(35, 24, 21, 841), - Trans(35, 25, 21, 841), - Trans(35, 26, 21, 841), - Trans(35, 31, 21, 841), - Trans(35, 48, 21, 841), - Trans(35, 52, 21, 841), - Trans(36, 5, 21, 841), - Trans(36, 6, 21, 841), - Trans(36, 7, 21, 841), - Trans(36, 8, 21, 841), - Trans(36, 9, 21, 841), - Trans(36, 10, 21, 841), - Trans(36, 11, 21, 841), - Trans(36, 18, 21, 841), - Trans(36, 24, 21, 841), - Trans(36, 25, 21, 841), - Trans(36, 26, 21, 841), - Trans(36, 27, 21, 841), - Trans(36, 39, 21, 841), - Trans(36, 40, 21, 841), - Trans(36, 42, 21, 841), - Trans(36, 54, 21, 841), - Trans(36, 58, 21, 841), - Trans(36, 71, 21, 841), - Trans(36, 77, 21, 841), - Trans(36, 84, 21, 841), - Trans(36, 87, 21, 841), - Trans(36, 89, 21, 841), - Trans(36, 106, 21, 841), - Trans(36, 114, 21, 841), - Trans(36, 115, 21, 841), - Trans(37, 5, 21, 841), - Trans(37, 16, 21, 841), - Trans(37, 17, 21, 841), - Trans(37, 18, 21, 841), - Trans(37, 19, 21, 841), - Trans(37, 20, 21, 841), - Trans(37, 21, 21, 841), - Trans(37, 22, 21, 841), - Trans(37, 23, 21, 841), - Trans(37, 24, 21, 841), - Trans(37, 25, 21, 841), - Trans(37, 26, 21, 841), - Trans(37, 30, 21, 841), - Trans(37, 31, 21, 841), - Trans(37, 35, 21, 841), - Trans(37, 41, 21, 841), - Trans(37, 42, 21, 841), - Trans(37, 48, 21, 841), - Trans(37, 52, 21, 841), - Trans(38, 5, 21, 841), - Trans(38, 16, 21, 841), - Trans(38, 17, 21, 841), - Trans(38, 18, 21, 841), - Trans(38, 19, 21, 841), - Trans(38, 20, 21, 841), - Trans(38, 21, 21, 841), - Trans(38, 22, 21, 841), - Trans(38, 23, 21, 841), - Trans(38, 24, 21, 841), - Trans(38, 25, 21, 841), - Trans(38, 26, 21, 841), - Trans(38, 29, 21, 841), - Trans(38, 30, 21, 841), - Trans(38, 31, 21, 841), - Trans(38, 35, 21, 841), - Trans(38, 41, 21, 841), - Trans(38, 42, 21, 841), - Trans(38, 48, 21, 841), - Trans(38, 52, 21, 841), - Trans(39, 31, 21, 841), - Trans(39, 37, 21, 841), - Trans(39, 40, 21, 841), - Trans(39, 44, 21, 841), - Trans(39, 49, 21, 841), - Trans(39, 50, 21, 841), - Trans(39, 51, 21, 841), - Trans(39, 61, 21, 841), - Trans(39, 65, 21, 841), - Trans(39, 66, 21, 841), - Trans(39, 67, 21, 841), - Trans(39, 71, 21, 841), - Trans(39, 72, 21, 841), - Trans(39, 74, 21, 841), - Trans(39, 78, 21, 841), - Trans(39, 81, 21, 841), - Trans(39, 82, 21, 841), - Trans(39, 105, 21, 841), - Trans(39, 108, 21, 841), - Trans(39, 111, 21, 841), - Trans(39, 112, 21, 841), - Trans(39, 113, 21, 841), - Trans(40, 5, 21, 841), - Trans(40, 31, 21, 841), - Trans(40, 37, 21, 841), - Trans(40, 40, 21, 841), - Trans(40, 44, 21, 841), - Trans(40, 49, 21, 841), - Trans(40, 50, 21, 841), - Trans(40, 51, 21, 841), - Trans(40, 61, 21, 841), - Trans(40, 65, 21, 841), - Trans(40, 66, 21, 841), - Trans(40, 67, 21, 841), - Trans(40, 71, 21, 841), - Trans(40, 72, 21, 841), - Trans(40, 74, 21, 841), - Trans(40, 78, 21, 841), - Trans(40, 81, 21, 841), - Trans(40, 82, 21, 841), - Trans(40, 105, 21, 841), - Trans(40, 108, 21, 841), - Trans(40, 111, 21, 841), - Trans(40, 112, 21, 841), - Trans(40, 113, 21, 841), - Trans(41, 40, 21, 841), - Trans(42, 5, 21, 841), - Trans(42, 44, 21, 841), - Trans(42, 54, 21, 841), - Trans(42, 66, 21, 841), - Trans(42, 70, 21, 841), - Trans(42, 71, 21, 841), - Trans(42, 81, 21, 841), - Trans(42, 100, 21, 841), - Trans(42, 101, 21, 841), - Trans(42, 106, 21, 841), - Trans(42, 114, 21, 841), - Trans(42, 115, 21, 841), - Trans(43, 40, 21, 841), - Trans(43, 42, 21, 841), - Trans(44, 41, 21, 841), - Trans(45, 42, 21, 841), - Trans(46, 114, 21, 841), - Trans(46, 115, 21, 841), - Trans(47, 5, 21, 841), - Trans(47, 30, 21, 841), - Trans(47, 47, 21, 841), - Trans(48, 5, 21, 841), - Trans(48, 29, 21, 841), - Trans(48, 30, 21, 841), - Trans(48, 47, 21, 841), - Trans(49, 115, 21, 841), - Trans(50, 5, 21, 841), - Trans(50, 35, 21, 841), - Trans(50, 36, 21, 841), - Trans(50, 41, 21, 841), - Trans(51, 5, 21, 841), - Trans(51, 31, 21, 841), - Trans(51, 40, 21, 841), - Trans(52, 5, 21, 841), - Trans(52, 80, 21, 841), - Trans(53, 5, 21, 841), - Trans(53, 13, 21, 841), - Trans(53, 29, 21, 841), - Trans(53, 40, 21, 841), - Trans(53, 42, 21, 841), - Trans(54, 5, 21, 841), - Trans(54, 31, 21, 841), - Trans(55, 5, 21, 841), - Trans(55, 29, 21, 841), - Trans(55, 40, 21, 841), - Trans(56, 5, 21, 841), - Trans(56, 36, 21, 841), + Trans(22, 0, 21, 851), + Trans(22, 31, 21, 851), + Trans(22, 37, 21, 851), + Trans(22, 40, 21, 851), + Trans(22, 44, 21, 851), + Trans(22, 49, 21, 851), + Trans(22, 50, 21, 851), + Trans(22, 51, 21, 851), + Trans(22, 60, 21, 851), + Trans(22, 61, 21, 851), + Trans(22, 62, 21, 851), + Trans(22, 66, 21, 851), + Trans(22, 67, 21, 851), + Trans(22, 68, 21, 851), + Trans(22, 72, 21, 851), + Trans(22, 73, 21, 851), + Trans(22, 74, 21, 851), + Trans(22, 75, 21, 851), + Trans(22, 79, 21, 851), + Trans(22, 80, 21, 851), + Trans(22, 82, 21, 851), + Trans(22, 83, 21, 851), + Trans(22, 87, 21, 851), + Trans(22, 91, 21, 851), + Trans(22, 93, 21, 851), + Trans(22, 94, 21, 851), + Trans(22, 107, 21, 851), + Trans(22, 110, 21, 851), + Trans(22, 113, 21, 851), + Trans(22, 114, 21, 851), + Trans(22, 115, 21, 851), + Trans(23, 5, 21, 851), + Trans(23, 117, 21, 851), + Trans(24, 5, 21, 851), + Trans(24, 41, 21, 851), + Trans(25, 5, 21, 851), + Trans(25, 31, 21, 851), + Trans(25, 37, 21, 851), + Trans(25, 40, 21, 851), + Trans(25, 44, 21, 851), + Trans(25, 49, 21, 851), + Trans(25, 50, 21, 851), + Trans(25, 51, 21, 851), + Trans(25, 61, 21, 851), + Trans(25, 62, 21, 851), + Trans(25, 66, 21, 851), + Trans(25, 67, 21, 851), + Trans(25, 68, 21, 851), + Trans(25, 72, 21, 851), + Trans(25, 73, 21, 851), + Trans(25, 74, 21, 851), + Trans(25, 75, 21, 851), + Trans(25, 79, 21, 851), + Trans(25, 80, 21, 851), + Trans(25, 82, 21, 851), + Trans(25, 83, 21, 851), + Trans(25, 87, 21, 851), + Trans(25, 91, 21, 851), + Trans(25, 93, 21, 851), + Trans(25, 94, 21, 851), + Trans(25, 107, 21, 851), + Trans(25, 110, 21, 851), + Trans(25, 113, 21, 851), + Trans(25, 114, 21, 851), + Trans(25, 115, 21, 851), + Trans(26, 0, 21, 851), + Trans(26, 5, 21, 851), + Trans(26, 31, 21, 851), + Trans(26, 37, 21, 851), + Trans(26, 40, 21, 851), + Trans(26, 44, 21, 851), + Trans(26, 49, 21, 851), + Trans(26, 50, 21, 851), + Trans(26, 51, 21, 851), + Trans(26, 60, 21, 851), + Trans(26, 61, 21, 851), + Trans(26, 62, 21, 851), + Trans(26, 66, 21, 851), + Trans(26, 67, 21, 851), + Trans(26, 68, 21, 851), + Trans(26, 72, 21, 851), + Trans(26, 73, 21, 851), + Trans(26, 74, 21, 851), + Trans(26, 75, 21, 851), + Trans(26, 79, 21, 851), + Trans(26, 80, 21, 851), + Trans(26, 82, 21, 851), + Trans(26, 83, 21, 851), + Trans(26, 87, 21, 851), + Trans(26, 91, 21, 851), + Trans(26, 93, 21, 851), + Trans(26, 94, 21, 851), + Trans(26, 107, 21, 851), + Trans(26, 110, 21, 851), + Trans(26, 113, 21, 851), + Trans(26, 114, 21, 851), + Trans(26, 115, 21, 851), + Trans(27, 5, 21, 851), + Trans(27, 40, 21, 851), + Trans(28, 5, 21, 851), + Trans(28, 40, 21, 851), + Trans(28, 42, 21, 851), + Trans(29, 5, 21, 851), + Trans(29, 31, 21, 851), + Trans(29, 40, 21, 851), + Trans(29, 72, 21, 851), + Trans(30, 5, 21, 851), + Trans(30, 42, 21, 851), + Trans(31, 5, 21, 851), + Trans(31, 6, 21, 851), + Trans(31, 7, 21, 851), + Trans(31, 8, 21, 851), + Trans(31, 9, 21, 851), + Trans(31, 10, 21, 851), + Trans(31, 11, 21, 851), + Trans(31, 18, 21, 851), + Trans(31, 24, 21, 851), + Trans(31, 25, 21, 851), + Trans(31, 26, 21, 851), + Trans(31, 27, 21, 851), + Trans(31, 39, 21, 851), + Trans(31, 40, 21, 851), + Trans(31, 42, 21, 851), + Trans(31, 54, 21, 851), + Trans(31, 72, 21, 851), + Trans(31, 78, 21, 851), + Trans(31, 85, 21, 851), + Trans(31, 88, 21, 851), + Trans(31, 90, 21, 851), + Trans(31, 108, 21, 851), + Trans(31, 116, 21, 851), + Trans(31, 117, 21, 851), + Trans(32, 5, 21, 851), + Trans(32, 116, 21, 851), + Trans(32, 117, 21, 851), + Trans(33, 5, 21, 851), + Trans(33, 87, 21, 851), + Trans(34, 5, 21, 851), + Trans(34, 80, 21, 851), + Trans(34, 87, 21, 851), + Trans(34, 91, 21, 851), + Trans(34, 93, 21, 851), + Trans(35, 6, 21, 851), + Trans(35, 7, 21, 851), + Trans(35, 8, 21, 851), + Trans(35, 9, 21, 851), + Trans(35, 10, 21, 851), + Trans(35, 11, 21, 851), + Trans(35, 18, 21, 851), + Trans(35, 24, 21, 851), + Trans(35, 25, 21, 851), + Trans(35, 26, 21, 851), + Trans(35, 27, 21, 851), + Trans(35, 39, 21, 851), + Trans(35, 40, 21, 851), + Trans(35, 42, 21, 851), + Trans(35, 54, 21, 851), + Trans(35, 72, 21, 851), + Trans(35, 78, 21, 851), + Trans(35, 85, 21, 851), + Trans(35, 88, 21, 851), + Trans(35, 90, 21, 851), + Trans(35, 108, 21, 851), + Trans(35, 116, 21, 851), + Trans(35, 117, 21, 851), + Trans(36, 5, 21, 851), + Trans(36, 16, 21, 851), + Trans(36, 17, 21, 851), + Trans(36, 18, 21, 851), + Trans(36, 19, 21, 851), + Trans(36, 20, 21, 851), + Trans(36, 21, 21, 851), + Trans(36, 22, 21, 851), + Trans(36, 23, 21, 851), + Trans(36, 24, 21, 851), + Trans(36, 25, 21, 851), + Trans(36, 26, 21, 851), + Trans(36, 31, 21, 851), + Trans(36, 48, 21, 851), + Trans(36, 52, 21, 851), + Trans(37, 5, 21, 851), + Trans(37, 6, 21, 851), + Trans(37, 7, 21, 851), + Trans(37, 8, 21, 851), + Trans(37, 9, 21, 851), + Trans(37, 10, 21, 851), + Trans(37, 11, 21, 851), + Trans(37, 18, 21, 851), + Trans(37, 24, 21, 851), + Trans(37, 25, 21, 851), + Trans(37, 26, 21, 851), + Trans(37, 27, 21, 851), + Trans(37, 39, 21, 851), + Trans(37, 40, 21, 851), + Trans(37, 42, 21, 851), + Trans(37, 54, 21, 851), + Trans(37, 59, 21, 851), + Trans(37, 72, 21, 851), + Trans(37, 78, 21, 851), + Trans(37, 85, 21, 851), + Trans(37, 88, 21, 851), + Trans(37, 90, 21, 851), + Trans(37, 108, 21, 851), + Trans(37, 116, 21, 851), + Trans(37, 117, 21, 851), + Trans(38, 5, 21, 851), + Trans(38, 16, 21, 851), + Trans(38, 17, 21, 851), + Trans(38, 18, 21, 851), + Trans(38, 19, 21, 851), + Trans(38, 20, 21, 851), + Trans(38, 21, 21, 851), + Trans(38, 22, 21, 851), + Trans(38, 23, 21, 851), + Trans(38, 24, 21, 851), + Trans(38, 25, 21, 851), + Trans(38, 26, 21, 851), + Trans(38, 30, 21, 851), + Trans(38, 31, 21, 851), + Trans(38, 35, 21, 851), + Trans(38, 41, 21, 851), + Trans(38, 42, 21, 851), + Trans(38, 48, 21, 851), + Trans(38, 52, 21, 851), + Trans(39, 5, 21, 851), + Trans(39, 16, 21, 851), + Trans(39, 17, 21, 851), + Trans(39, 18, 21, 851), + Trans(39, 19, 21, 851), + Trans(39, 20, 21, 851), + Trans(39, 21, 21, 851), + Trans(39, 22, 21, 851), + Trans(39, 23, 21, 851), + Trans(39, 24, 21, 851), + Trans(39, 25, 21, 851), + Trans(39, 26, 21, 851), + Trans(39, 29, 21, 851), + Trans(39, 30, 21, 851), + Trans(39, 31, 21, 851), + Trans(39, 35, 21, 851), + Trans(39, 41, 21, 851), + Trans(39, 42, 21, 851), + Trans(39, 48, 21, 851), + Trans(39, 52, 21, 851), + Trans(40, 31, 21, 851), + Trans(40, 37, 21, 851), + Trans(40, 40, 21, 851), + Trans(40, 44, 21, 851), + Trans(40, 49, 21, 851), + Trans(40, 50, 21, 851), + Trans(40, 51, 21, 851), + Trans(40, 62, 21, 851), + Trans(40, 66, 21, 851), + Trans(40, 67, 21, 851), + Trans(40, 68, 21, 851), + Trans(40, 72, 21, 851), + Trans(40, 73, 21, 851), + Trans(40, 75, 21, 851), + Trans(40, 79, 21, 851), + Trans(40, 82, 21, 851), + Trans(40, 83, 21, 851), + Trans(40, 107, 21, 851), + Trans(40, 110, 21, 851), + Trans(40, 113, 21, 851), + Trans(40, 114, 21, 851), + Trans(40, 115, 21, 851), + Trans(41, 5, 21, 851), + Trans(41, 31, 21, 851), + Trans(41, 37, 21, 851), + Trans(41, 40, 21, 851), + Trans(41, 44, 21, 851), + Trans(41, 49, 21, 851), + Trans(41, 50, 21, 851), + Trans(41, 51, 21, 851), + Trans(41, 62, 21, 851), + Trans(41, 66, 21, 851), + Trans(41, 67, 21, 851), + Trans(41, 68, 21, 851), + Trans(41, 72, 21, 851), + Trans(41, 73, 21, 851), + Trans(41, 75, 21, 851), + Trans(41, 79, 21, 851), + Trans(41, 82, 21, 851), + Trans(41, 83, 21, 851), + Trans(41, 107, 21, 851), + Trans(41, 110, 21, 851), + Trans(41, 113, 21, 851), + Trans(41, 114, 21, 851), + Trans(41, 115, 21, 851), + Trans(42, 40, 21, 851), + Trans(43, 5, 21, 851), + Trans(43, 44, 21, 851), + Trans(43, 54, 21, 851), + Trans(43, 67, 21, 851), + Trans(43, 71, 21, 851), + Trans(43, 72, 21, 851), + Trans(43, 82, 21, 851), + Trans(43, 102, 21, 851), + Trans(43, 103, 21, 851), + Trans(43, 108, 21, 851), + Trans(43, 116, 21, 851), + Trans(43, 117, 21, 851), + Trans(44, 40, 21, 851), + Trans(44, 42, 21, 851), + Trans(45, 41, 21, 851), + Trans(46, 42, 21, 851), + Trans(47, 116, 21, 851), + Trans(47, 117, 21, 851), + Trans(48, 5, 21, 851), + Trans(48, 30, 21, 851), + Trans(48, 47, 21, 851), + Trans(49, 5, 21, 851), + Trans(49, 29, 21, 851), + Trans(49, 30, 21, 851), + Trans(49, 47, 21, 851), + Trans(50, 117, 21, 851), + Trans(51, 5, 21, 851), + Trans(51, 35, 21, 851), + Trans(51, 36, 21, 851), + Trans(51, 41, 21, 851), + Trans(52, 5, 21, 851), + Trans(52, 31, 21, 851), + Trans(52, 40, 21, 851), + Trans(53, 5, 21, 851), + Trans(53, 81, 21, 851), + Trans(54, 5, 21, 851), + Trans(54, 13, 21, 851), + Trans(54, 29, 21, 851), + Trans(54, 40, 21, 851), + Trans(54, 42, 21, 851), + Trans(55, 5, 21, 851), + Trans(55, 31, 21, 851), + Trans(56, 5, 21, 851), + Trans(56, 29, 21, 851), + Trans(56, 40, 21, 851), + Trans(57, 5, 21, 851), + Trans(57, 36, 21, 851), ], k: 3, }, - /* 414 - "ModuleIfDeclarationOpt" */ + /* 419 - "ModuleIfDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 2, 843), - Trans(0, 37, 2, 843), - Trans(0, 40, 2, 843), - Trans(0, 44, 2, 843), - Trans(0, 49, 2, 843), - Trans(0, 50, 2, 843), - Trans(0, 51, 2, 843), - Trans(0, 59, 1, 842), - Trans(0, 61, 2, 843), - Trans(0, 65, 2, 843), - Trans(0, 66, 2, 843), - Trans(0, 67, 2, 843), - Trans(0, 71, 2, 843), - Trans(0, 72, 2, 843), - Trans(0, 74, 2, 843), - Trans(0, 78, 2, 843), - Trans(0, 81, 2, 843), - Trans(0, 82, 2, 843), - Trans(0, 105, 2, 843), - Trans(0, 108, 2, 843), - Trans(0, 111, 2, 843), - Trans(0, 112, 2, 843), - Trans(0, 113, 2, 843), + Trans(0, 31, 2, 853), + Trans(0, 37, 2, 853), + Trans(0, 40, 2, 853), + Trans(0, 44, 2, 853), + Trans(0, 49, 2, 853), + Trans(0, 50, 2, 853), + Trans(0, 51, 2, 853), + Trans(0, 60, 1, 852), + Trans(0, 62, 2, 853), + Trans(0, 66, 2, 853), + Trans(0, 67, 2, 853), + Trans(0, 68, 2, 853), + Trans(0, 72, 2, 853), + Trans(0, 73, 2, 853), + Trans(0, 75, 2, 853), + Trans(0, 79, 2, 853), + Trans(0, 82, 2, 853), + Trans(0, 83, 2, 853), + Trans(0, 107, 2, 853), + Trans(0, 110, 2, 853), + Trans(0, 113, 2, 853), + Trans(0, 114, 2, 853), + Trans(0, 115, 2, 853), ], k: 1, }, - /* 415 - "ModuleItem" */ + /* 420 - "ModuleItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 14, 875), - Trans(0, 49, 7, 868), - Trans(0, 50, 6, 867), - Trans(0, 51, 8, 869), - Trans(0, 61, 12, 873), - Trans(0, 65, 17, 878), - Trans(0, 66, 11, 872), - Trans(0, 67, 9, 870), - Trans(0, 71, 10, 871), - Trans(0, 72, 15, 876), - Trans(0, 74, 16, 877), - Trans(0, 78, 3, 864), - Trans(0, 81, 1, 862), - Trans(0, 82, 5, 866), - Trans(0, 105, 13, 874), - Trans(0, 108, 4, 865), - Trans(0, 111, 13, 874), - Trans(0, 112, 18, 879), - Trans(0, 113, 2, 863), + Trans(0, 31, 14, 885), + Trans(0, 49, 7, 878), + Trans(0, 50, 6, 877), + Trans(0, 51, 8, 879), + Trans(0, 62, 12, 883), + Trans(0, 66, 17, 888), + Trans(0, 67, 11, 882), + Trans(0, 68, 9, 880), + Trans(0, 72, 10, 881), + Trans(0, 73, 15, 886), + Trans(0, 75, 16, 887), + Trans(0, 79, 3, 874), + Trans(0, 82, 1, 872), + Trans(0, 83, 5, 876), + Trans(0, 107, 13, 884), + Trans(0, 110, 4, 875), + Trans(0, 113, 13, 884), + Trans(0, 114, 18, 889), + Trans(0, 115, 2, 873), ], k: 1, }, - /* 416 - "ModuleNamedBlock" */ + /* 421 - "ModuleNamedBlock" */ LookaheadDFA { - prod0: 847, + prod0: 857, transitions: &[], k: 0, }, - /* 417 - "ModuleNamedBlockList" */ + /* 422 - "ModuleNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 848), - Trans(0, 37, 1, 848), - Trans(0, 40, 1, 848), - Trans(0, 44, 2, 849), - Trans(0, 49, 1, 848), - Trans(0, 50, 1, 848), - Trans(0, 51, 1, 848), - Trans(0, 61, 1, 848), - Trans(0, 65, 1, 848), - Trans(0, 66, 1, 848), - Trans(0, 67, 1, 848), - Trans(0, 71, 1, 848), - Trans(0, 72, 1, 848), - Trans(0, 74, 1, 848), - Trans(0, 78, 1, 848), - Trans(0, 81, 1, 848), - Trans(0, 82, 1, 848), - Trans(0, 105, 1, 848), - Trans(0, 108, 1, 848), - Trans(0, 111, 1, 848), - Trans(0, 112, 1, 848), - Trans(0, 113, 1, 848), + Trans(0, 31, 1, 858), + Trans(0, 37, 1, 858), + Trans(0, 40, 1, 858), + Trans(0, 44, 2, 859), + Trans(0, 49, 1, 858), + Trans(0, 50, 1, 858), + Trans(0, 51, 1, 858), + Trans(0, 62, 1, 858), + Trans(0, 66, 1, 858), + Trans(0, 67, 1, 858), + Trans(0, 68, 1, 858), + Trans(0, 72, 1, 858), + Trans(0, 73, 1, 858), + Trans(0, 75, 1, 858), + Trans(0, 79, 1, 858), + Trans(0, 82, 1, 858), + Trans(0, 83, 1, 858), + Trans(0, 107, 1, 858), + Trans(0, 110, 1, 858), + Trans(0, 113, 1, 858), + Trans(0, 114, 1, 858), + Trans(0, 115, 1, 858), ], k: 1, }, - /* 418 - "ModuleOptionalNamedBlock" */ + /* 423 - "ModuleOptionalNamedBlock" */ LookaheadDFA { - prod0: 850, + prod0: 860, transitions: &[], k: 0, }, - /* 419 - "ModuleOptionalNamedBlockList" */ + /* 424 - "ModuleOptionalNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 851), - Trans(0, 37, 1, 851), - Trans(0, 40, 1, 851), - Trans(0, 44, 2, 852), - Trans(0, 49, 1, 851), - Trans(0, 50, 1, 851), - Trans(0, 51, 1, 851), - Trans(0, 61, 1, 851), - Trans(0, 65, 1, 851), - Trans(0, 66, 1, 851), - Trans(0, 67, 1, 851), - Trans(0, 71, 1, 851), - Trans(0, 72, 1, 851), - Trans(0, 74, 1, 851), - Trans(0, 78, 1, 851), - Trans(0, 81, 1, 851), - Trans(0, 82, 1, 851), - Trans(0, 105, 1, 851), - Trans(0, 108, 1, 851), - Trans(0, 111, 1, 851), - Trans(0, 112, 1, 851), - Trans(0, 113, 1, 851), + Trans(0, 31, 1, 861), + Trans(0, 37, 1, 861), + Trans(0, 40, 1, 861), + Trans(0, 44, 2, 862), + Trans(0, 49, 1, 861), + Trans(0, 50, 1, 861), + Trans(0, 51, 1, 861), + Trans(0, 62, 1, 861), + Trans(0, 66, 1, 861), + Trans(0, 67, 1, 861), + Trans(0, 68, 1, 861), + Trans(0, 72, 1, 861), + Trans(0, 73, 1, 861), + Trans(0, 75, 1, 861), + Trans(0, 79, 1, 861), + Trans(0, 82, 1, 861), + Trans(0, 83, 1, 861), + Trans(0, 107, 1, 861), + Trans(0, 110, 1, 861), + Trans(0, 113, 1, 861), + Trans(0, 114, 1, 861), + Trans(0, 115, 1, 861), ], k: 1, }, - /* 420 - "ModuleOptionalNamedBlockOpt" */ + /* 425 - "ModuleOptionalNamedBlockOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 31, 1, 853), Trans(0, 40, 2, 854)], + transitions: &[Trans(0, 31, 1, 863), Trans(0, 40, 2, 864)], k: 1, }, - /* 421 - "ModuleTerm" */ + /* 426 - "ModuleTerm" */ LookaheadDFA { - prod0: 81, + prod0: 82, transitions: &[], k: 0, }, - /* 422 - "ModuleToken" */ + /* 427 - "ModuleToken" */ LookaheadDFA { - prod0: 196, + prod0: 199, transitions: &[], k: 0, }, - /* 423 - "Msb" */ + /* 428 - "Msb" */ LookaheadDFA { - prod0: 309, + prod0: 314, transitions: &[], k: 0, }, - /* 424 - "MsbTerm" */ + /* 429 - "MsbTerm" */ LookaheadDFA { - prod0: 82, + prod0: 83, transitions: &[], k: 0, }, - /* 425 - "MsbToken" */ + /* 430 - "MsbToken" */ LookaheadDFA { - prod0: 197, + prod0: 200, transitions: &[], k: 0, }, - /* 426 - "Number" */ + /* 431 - "Number" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 7, 2, 338), - Trans(0, 8, 2, 338), - Trans(0, 9, 1, 337), - Trans(0, 10, 1, 337), - Trans(0, 11, 1, 337), + Trans(0, 7, 2, 344), + Trans(0, 8, 2, 344), + Trans(0, 9, 1, 343), + Trans(0, 10, 1, 343), + Trans(0, 11, 1, 343), ], k: 1, }, - /* 427 - "Operator01" */ + /* 432 - "Operator01" */ LookaheadDFA { - prod0: 234, + prod0: 238, transitions: &[], k: 0, }, - /* 428 - "Operator01Term" */ + /* 433 - "Operator01Term" */ LookaheadDFA { prod0: 18, transitions: &[], k: 0, }, - /* 429 - "Operator01Token" */ + /* 434 - "Operator01Token" */ LookaheadDFA { - prod0: 123, + prod0: 125, transitions: &[], k: 0, }, - /* 430 - "Operator02" */ + /* 435 - "Operator02" */ LookaheadDFA { - prod0: 235, + prod0: 239, transitions: &[], k: 0, }, - /* 431 - "Operator02Term" */ + /* 436 - "Operator02Term" */ LookaheadDFA { prod0: 17, transitions: &[], k: 0, }, - /* 432 - "Operator02Token" */ + /* 437 - "Operator02Token" */ LookaheadDFA { - prod0: 124, + prod0: 126, transitions: &[], k: 0, }, - /* 433 - "Operator03" */ + /* 438 - "Operator03" */ LookaheadDFA { - prod0: 236, + prod0: 240, transitions: &[], k: 0, }, - /* 434 - "Operator03Term" */ + /* 439 - "Operator03Term" */ LookaheadDFA { prod0: 21, transitions: &[], k: 0, }, - /* 435 - "Operator03Token" */ + /* 440 - "Operator03Token" */ LookaheadDFA { - prod0: 125, + prod0: 127, transitions: &[], k: 0, }, - /* 436 - "Operator04" */ + /* 441 - "Operator04" */ LookaheadDFA { - prod0: 237, + prod0: 241, transitions: &[], k: 0, }, - /* 437 - "Operator04Term" */ + /* 442 - "Operator04Term" */ LookaheadDFA { prod0: 20, transitions: &[], k: 0, }, - /* 438 - "Operator04Token" */ + /* 443 - "Operator04Token" */ LookaheadDFA { - prod0: 126, + prod0: 128, transitions: &[], k: 0, }, - /* 439 - "Operator05" */ + /* 444 - "Operator05" */ LookaheadDFA { - prod0: 238, + prod0: 242, transitions: &[], k: 0, }, - /* 440 - "Operator05Term" */ + /* 445 - "Operator05Term" */ LookaheadDFA { prod0: 19, transitions: &[], k: 0, }, - /* 441 - "Operator05Token" */ + /* 446 - "Operator05Token" */ LookaheadDFA { - prod0: 127, + prod0: 129, transitions: &[], k: 0, }, - /* 442 - "Operator06" */ + /* 447 - "Operator06" */ LookaheadDFA { - prod0: 239, + prod0: 243, transitions: &[], k: 0, }, - /* 443 - "Operator06Term" */ + /* 448 - "Operator06Term" */ LookaheadDFA { prod0: 16, transitions: &[], k: 0, }, - /* 444 - "Operator06Token" */ + /* 449 - "Operator06Token" */ LookaheadDFA { - prod0: 128, + prod0: 130, transitions: &[], k: 0, }, - /* 445 - "Operator07" */ + /* 450 - "Operator07" */ LookaheadDFA { - prod0: 240, + prod0: 244, transitions: &[], k: 0, }, - /* 446 - "Operator07Term" */ + /* 451 - "Operator07Term" */ LookaheadDFA { prod0: 15, transitions: &[], k: 0, }, - /* 447 - "Operator07Token" */ + /* 452 - "Operator07Token" */ LookaheadDFA { - prod0: 129, + prod0: 131, transitions: &[], k: 0, }, - /* 448 - "Operator08" */ + /* 453 - "Operator08" */ LookaheadDFA { - prod0: 241, + prod0: 245, transitions: &[], k: 0, }, - /* 449 - "Operator08Term" */ + /* 454 - "Operator08Term" */ LookaheadDFA { prod0: 14, transitions: &[], k: 0, }, - /* 450 - "Operator08Token" */ + /* 455 - "Operator08Token" */ LookaheadDFA { - prod0: 130, + prod0: 132, transitions: &[], k: 0, }, - /* 451 - "Operator09" */ + /* 456 - "Operator09" */ LookaheadDFA { - prod0: 242, + prod0: 246, transitions: &[], k: 0, }, - /* 452 - "Operator09Term" */ + /* 457 - "Operator09Term" */ LookaheadDFA { prod0: 13, transitions: &[], k: 0, }, - /* 453 - "Operator09Token" */ + /* 458 - "Operator09Token" */ LookaheadDFA { - prod0: 131, + prod0: 133, transitions: &[], k: 0, }, - /* 454 - "Operator10" */ + /* 459 - "Operator10" */ LookaheadDFA { - prod0: 243, + prod0: 247, transitions: &[], k: 0, }, - /* 455 - "Operator10Term" */ + /* 460 - "Operator10Term" */ LookaheadDFA { prod0: 12, transitions: &[], k: 0, }, - /* 456 - "Operator10Token" */ + /* 461 - "Operator10Token" */ LookaheadDFA { - prod0: 132, + prod0: 134, transitions: &[], k: 0, }, - /* 457 - "Operator11" */ + /* 462 - "Operator11" */ LookaheadDFA { - prod0: 244, + prod0: 248, transitions: &[], k: 0, }, - /* 458 - "Operator11Term" */ + /* 463 - "Operator11Term" */ LookaheadDFA { prod0: 11, transitions: &[], k: 0, }, - /* 459 - "Operator11Token" */ + /* 464 - "Operator11Token" */ LookaheadDFA { - prod0: 133, + prod0: 135, transitions: &[], k: 0, }, - /* 460 - "Output" */ + /* 465 - "Output" */ LookaheadDFA { - prod0: 310, + prod0: 315, transitions: &[], k: 0, }, - /* 461 - "OutputTerm" */ + /* 466 - "OutputTerm" */ LookaheadDFA { - prod0: 83, + prod0: 84, transitions: &[], k: 0, }, - /* 462 - "OutputToken" */ + /* 467 - "OutputToken" */ LookaheadDFA { - prod0: 198, + prod0: 201, transitions: &[], k: 0, }, - /* 463 - "Outside" */ + /* 468 - "Outside" */ LookaheadDFA { - prod0: 311, + prod0: 316, transitions: &[], k: 0, }, - /* 464 - "OutsideExpression" */ + /* 469 - "OutsideExpression" */ LookaheadDFA { - prod0: 472, + prod0: 478, transitions: &[], k: 0, }, - /* 465 - "OutsideTerm" */ + /* 470 - "OutsideTerm" */ LookaheadDFA { - prod0: 84, + prod0: 85, transitions: &[], k: 0, }, - /* 466 - "OutsideToken" */ + /* 471 - "OutsideToken" */ LookaheadDFA { - prod0: 199, + prod0: 202, transitions: &[], k: 0, }, - /* 467 - "Package" */ + /* 472 - "Package" */ LookaheadDFA { - prod0: 312, + prod0: 317, transitions: &[], k: 0, }, - /* 468 - "PackageDeclaration" */ + /* 473 - "PackageDeclaration" */ LookaheadDFA { - prod0: 926, + prod0: 936, transitions: &[], k: 0, }, - /* 469 - "PackageDeclarationList" */ + /* 474 - "PackageDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 927), - Trans(0, 40, 1, 927), - Trans(0, 44, 2, 928), - Trans(0, 61, 1, 927), - Trans(0, 62, 1, 927), - Trans(0, 65, 1, 927), - Trans(0, 67, 1, 927), - Trans(0, 72, 1, 927), - Trans(0, 74, 1, 927), - Trans(0, 82, 1, 927), - Trans(0, 105, 1, 927), - Trans(0, 108, 1, 927), - Trans(0, 111, 1, 927), - Trans(0, 113, 1, 927), + Trans(0, 37, 1, 937), + Trans(0, 40, 1, 937), + Trans(0, 44, 2, 938), + Trans(0, 62, 1, 937), + Trans(0, 63, 1, 937), + Trans(0, 66, 1, 937), + Trans(0, 68, 1, 937), + Trans(0, 73, 1, 937), + Trans(0, 75, 1, 937), + Trans(0, 83, 1, 937), + Trans(0, 107, 1, 937), + Trans(0, 110, 1, 937), + Trans(0, 113, 1, 937), + Trans(0, 115, 1, 937), ], k: 1, }, - /* 470 - "PackageDeclarationOpt" */ + /* 475 - "PackageDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 90, 2, 932), Trans(0, 92, 1, 931)], + transitions: &[Trans(0, 91, 2, 942), Trans(0, 94, 1, 941)], k: 1, }, - /* 471 - "PackageDeclarationOpt0" */ + /* 476 - "PackageDeclarationOpt0" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 1, 929), Trans(0, 40, 2, 930)], + transitions: &[Trans(0, 29, 1, 939), Trans(0, 40, 2, 940)], k: 1, }, - /* 472 - "PackageGroup" */ + /* 477 - "PackageGroup" */ LookaheadDFA { - prod0: 933, + prod0: 943, transitions: &[], k: 0, }, - /* 473 - "PackageGroupGroup" */ + /* 478 - "PackageGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 40, 1, 934), - Trans(0, 61, 2, 937), - Trans(0, 62, 2, 937), - Trans(0, 65, 2, 937), - Trans(0, 67, 2, 937), - Trans(0, 72, 2, 937), - Trans(0, 74, 2, 937), - Trans(0, 82, 2, 937), - Trans(0, 105, 2, 937), - Trans(0, 108, 2, 937), - Trans(0, 111, 2, 937), - Trans(0, 113, 2, 937), + Trans(0, 40, 1, 944), + Trans(0, 62, 2, 947), + Trans(0, 63, 2, 947), + Trans(0, 66, 2, 947), + Trans(0, 68, 2, 947), + Trans(0, 73, 2, 947), + Trans(0, 75, 2, 947), + Trans(0, 83, 2, 947), + Trans(0, 107, 2, 947), + Trans(0, 110, 2, 947), + Trans(0, 113, 2, 947), + Trans(0, 115, 2, 947), ], k: 1, }, - /* 474 - "PackageGroupGroupList" */ + /* 479 - "PackageGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 935), - Trans(0, 40, 1, 935), - Trans(0, 44, 2, 936), - Trans(0, 61, 1, 935), - Trans(0, 62, 1, 935), - Trans(0, 65, 1, 935), - Trans(0, 67, 1, 935), - Trans(0, 72, 1, 935), - Trans(0, 74, 1, 935), - Trans(0, 82, 1, 935), - Trans(0, 105, 1, 935), - Trans(0, 108, 1, 935), - Trans(0, 111, 1, 935), - Trans(0, 113, 1, 935), + Trans(0, 37, 1, 945), + Trans(0, 40, 1, 945), + Trans(0, 44, 2, 946), + Trans(0, 62, 1, 945), + Trans(0, 63, 1, 945), + Trans(0, 66, 1, 945), + Trans(0, 68, 1, 945), + Trans(0, 73, 1, 945), + Trans(0, 75, 1, 945), + Trans(0, 83, 1, 945), + Trans(0, 107, 1, 945), + Trans(0, 110, 1, 945), + Trans(0, 113, 1, 945), + Trans(0, 115, 1, 945), ], k: 1, }, - /* 475 - "PackageGroupList" */ + /* 480 - "PackageGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 938), - Trans(0, 40, 2, 939), - Trans(0, 61, 2, 939), - Trans(0, 62, 2, 939), - Trans(0, 65, 2, 939), - Trans(0, 67, 2, 939), - Trans(0, 72, 2, 939), - Trans(0, 74, 2, 939), - Trans(0, 82, 2, 939), - Trans(0, 105, 2, 939), - Trans(0, 108, 2, 939), - Trans(0, 111, 2, 939), - Trans(0, 113, 2, 939), + Trans(0, 37, 1, 948), + Trans(0, 40, 2, 949), + Trans(0, 62, 2, 949), + Trans(0, 63, 2, 949), + Trans(0, 66, 2, 949), + Trans(0, 68, 2, 949), + Trans(0, 73, 2, 949), + Trans(0, 75, 2, 949), + Trans(0, 83, 2, 949), + Trans(0, 107, 2, 949), + Trans(0, 110, 2, 949), + Trans(0, 113, 2, 949), + Trans(0, 115, 2, 949), ], k: 1, }, - /* 476 - "PackageItem" */ + /* 481 - "PackageItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 61, 4, 943), - Trans(0, 62, 8, 947), - Trans(0, 65, 10, 949), - Trans(0, 67, 6, 945), - Trans(0, 72, 7, 946), - Trans(0, 74, 9, 948), - Trans(0, 82, 2, 941), - Trans(0, 105, 5, 944), - Trans(0, 108, 3, 942), - Trans(0, 111, 5, 944), - Trans(0, 113, 1, 940), + Trans(0, 62, 4, 953), + Trans(0, 63, 8, 957), + Trans(0, 66, 10, 959), + Trans(0, 68, 6, 955), + Trans(0, 73, 7, 956), + Trans(0, 75, 9, 958), + Trans(0, 83, 2, 951), + Trans(0, 107, 5, 954), + Trans(0, 110, 3, 952), + Trans(0, 113, 5, 954), + Trans(0, 115, 1, 950), ], k: 1, }, - /* 477 - "PackageTerm" */ + /* 482 - "PackageTerm" */ LookaheadDFA { - prod0: 85, + prod0: 86, transitions: &[], k: 0, }, - /* 478 - "PackageToken" */ + /* 483 - "PackageToken" */ LookaheadDFA { - prod0: 200, + prod0: 203, transitions: &[], k: 0, }, - /* 479 - "Param" */ + /* 484 - "Param" */ LookaheadDFA { - prod0: 313, + prod0: 318, transitions: &[], k: 0, }, - /* 480 - "ParamTerm" */ + /* 485 - "ParamTerm" */ LookaheadDFA { - prod0: 86, + prod0: 87, transitions: &[], k: 0, }, - /* 481 - "ParamToken" */ + /* 486 - "ParamToken" */ LookaheadDFA { - prod0: 201, + prod0: 204, transitions: &[], k: 0, }, - /* 482 - "PlusColon" */ + /* 487 - "PlusColon" */ LookaheadDFA { - prod0: 263, + prod0: 267, transitions: &[], k: 0, }, - /* 483 - "PlusColonTerm" */ + /* 488 - "PlusColonTerm" */ LookaheadDFA { prod0: 9, transitions: &[], k: 0, }, - /* 484 - "PlusColonToken" */ + /* 489 - "PlusColonToken" */ LookaheadDFA { - prod0: 152, + prod0: 154, transitions: &[], k: 0, }, - /* 485 - "PortDeclaration" */ + /* 490 - "PortDeclaration" */ LookaheadDFA { - prod0: 776, + prod0: 784, transitions: &[], k: 0, }, - /* 486 - "PortDeclarationGroup" */ + /* 491 - "PortDeclarationGroup" */ LookaheadDFA { - prod0: 784, + prod0: 792, transitions: &[], k: 0, }, - /* 487 - "PortDeclarationGroupGroup" */ + /* 492 - "PortDeclarationGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 785), Trans(0, 115, 2, 786)], + transitions: &[Trans(0, 40, 1, 793), Trans(0, 117, 2, 794)], k: 1, }, - /* 488 - "PortDeclarationGroupList" */ + /* 493 - "PortDeclarationGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 787), - Trans(0, 40, 2, 788), - Trans(0, 115, 2, 788), + Trans(0, 37, 1, 795), + Trans(0, 40, 2, 796), + Trans(0, 117, 2, 796), ], k: 1, }, - /* 489 - "PortDeclarationItem" */ + /* 494 - "PortDeclarationItem" */ LookaheadDFA { - prod0: 789, + prod0: 797, transitions: &[], k: 0, }, - /* 490 - "PortDeclarationItemGroup" */ + /* 495 - "PortDeclarationItemGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 28, 2, 791), - Trans(0, 72, 1, 790), - Trans(0, 75, 1, 790), - Trans(0, 76, 1, 790), - Trans(0, 79, 2, 791), - Trans(0, 85, 1, 790), - Trans(0, 88, 1, 790), - Trans(0, 93, 1, 790), + Trans(0, 28, 2, 799), + Trans(0, 73, 1, 798), + Trans(0, 76, 1, 798), + Trans(0, 77, 1, 798), + Trans(0, 80, 2, 799), + Trans(0, 86, 1, 798), + Trans(0, 89, 1, 798), + Trans(0, 95, 1, 798), ], k: 1, }, - /* 491 - "PortDeclarationList" */ + /* 496 - "PortDeclarationList" */ LookaheadDFA { - prod0: 779, + prod0: 787, transitions: &[], k: 0, }, - /* 492 - "PortDeclarationListList" */ + /* 497 - "PortDeclarationListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -11399,308 +11494,370 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 5, 6, -1), Trans(1, 37, 2, -1), Trans(1, 40, 4, -1), - Trans(1, 44, 15, -1), - Trans(1, 46, 16, -1), - Trans(1, 115, 5, -1), - Trans(2, 5, 3, 780), - Trans(2, 41, 3, 780), - Trans(4, 5, 3, 780), - Trans(4, 37, 3, 780), - Trans(4, 40, 3, 780), - Trans(4, 115, 3, 780), - Trans(5, 5, 3, 780), - Trans(5, 31, 3, 780), - Trans(6, 37, 3, 780), - Trans(6, 40, 3, 780), - Trans(6, 44, 12, 781), - Trans(6, 46, 12, 781), - Trans(6, 115, 3, 780), - Trans(7, 5, 13, -1), - Trans(7, 32, 14, -1), - Trans(7, 44, 15, -1), - Trans(7, 46, 16, -1), + Trans(1, 44, 16, -1), + Trans(1, 46, 17, -1), + Trans(1, 117, 5, -1), + Trans(2, 5, 3, 788), + Trans(2, 41, 3, 788), + Trans(4, 5, 3, 788), + Trans(4, 37, 3, 788), + Trans(4, 40, 3, 788), + Trans(4, 117, 3, 788), + Trans(5, 5, 3, 788), + Trans(5, 31, 3, 788), + Trans(6, 37, 3, 788), + Trans(6, 40, 3, 788), + Trans(6, 44, 13, 789), + Trans(6, 46, 13, 789), + Trans(6, 117, 3, 788), + Trans(7, 5, 14, -1), + Trans(7, 32, 15, -1), + Trans(7, 44, 16, -1), + Trans(7, 46, 17, -1), Trans(8, 5, 9, -1), Trans(8, 13, 10, -1), Trans(8, 40, 11, -1), - Trans(9, 13, 12, 781), - Trans(9, 40, 12, 781), - Trans(10, 5, 12, 781), - Trans(10, 53, 12, 781), - Trans(10, 55, 12, 781), - Trans(10, 56, 12, 781), - Trans(10, 57, 12, 781), - Trans(10, 63, 12, 781), - Trans(10, 64, 12, 781), - Trans(10, 68, 12, 781), - Trans(10, 69, 12, 781), - Trans(10, 83, 12, 781), - Trans(10, 95, 12, 781), - Trans(10, 96, 12, 781), - Trans(10, 97, 12, 781), - Trans(10, 98, 12, 781), - Trans(10, 99, 12, 781), - Trans(10, 102, 12, 781), - Trans(10, 104, 12, 781), - Trans(10, 107, 12, 781), - Trans(10, 109, 12, 781), - Trans(10, 110, 12, 781), - Trans(10, 114, 12, 781), - Trans(10, 115, 12, 781), - Trans(11, 5, 12, 781), - Trans(11, 31, 12, 781), - Trans(11, 37, 12, 781), - Trans(11, 40, 12, 781), - Trans(11, 44, 12, 781), - Trans(11, 49, 12, 781), - Trans(11, 50, 12, 781), - Trans(11, 51, 12, 781), - Trans(11, 54, 12, 781), - Trans(11, 61, 12, 781), - Trans(11, 65, 12, 781), - Trans(11, 66, 12, 781), - Trans(11, 67, 12, 781), - Trans(11, 70, 12, 781), - Trans(11, 71, 12, 781), - Trans(11, 72, 12, 781), - Trans(11, 74, 12, 781), - Trans(11, 78, 12, 781), - Trans(11, 81, 12, 781), - Trans(11, 82, 12, 781), - Trans(11, 100, 12, 781), - Trans(11, 101, 12, 781), - Trans(11, 105, 12, 781), - Trans(11, 106, 12, 781), - Trans(11, 108, 12, 781), - Trans(11, 111, 12, 781), - Trans(11, 112, 12, 781), - Trans(11, 113, 12, 781), - Trans(11, 114, 12, 781), - Trans(11, 115, 12, 781), - Trans(13, 32, 12, 781), - Trans(13, 44, 12, 781), - Trans(13, 46, 12, 781), - Trans(14, 5, 12, 781), - Trans(14, 37, 12, 781), - Trans(14, 40, 12, 781), - Trans(14, 44, 12, 781), - Trans(14, 46, 12, 781), - Trans(14, 115, 12, 781), - Trans(15, 5, 12, 781), - Trans(15, 32, 12, 781), - Trans(15, 44, 12, 781), - Trans(15, 46, 12, 781), - Trans(16, 5, 12, 781), - Trans(16, 13, 12, 781), - Trans(16, 40, 12, 781), + Trans(8, 47, 12, -1), + Trans(9, 13, 13, 789), + Trans(9, 40, 13, 789), + Trans(9, 47, 13, 789), + Trans(10, 5, 13, 789), + Trans(10, 53, 13, 789), + Trans(10, 55, 13, 789), + Trans(10, 56, 13, 789), + Trans(10, 57, 13, 789), + Trans(10, 64, 13, 789), + Trans(10, 65, 13, 789), + Trans(10, 69, 13, 789), + Trans(10, 70, 13, 789), + Trans(10, 84, 13, 789), + Trans(10, 97, 13, 789), + Trans(10, 98, 13, 789), + Trans(10, 99, 13, 789), + Trans(10, 100, 13, 789), + Trans(10, 101, 13, 789), + Trans(10, 104, 13, 789), + Trans(10, 106, 13, 789), + Trans(10, 109, 13, 789), + Trans(10, 111, 13, 789), + Trans(10, 112, 13, 789), + Trans(10, 116, 13, 789), + Trans(10, 117, 13, 789), + Trans(11, 5, 13, 789), + Trans(11, 31, 13, 789), + Trans(11, 37, 13, 789), + Trans(11, 40, 13, 789), + Trans(11, 44, 13, 789), + Trans(11, 49, 13, 789), + Trans(11, 50, 13, 789), + Trans(11, 51, 13, 789), + Trans(11, 54, 13, 789), + Trans(11, 62, 13, 789), + Trans(11, 66, 13, 789), + Trans(11, 67, 13, 789), + Trans(11, 68, 13, 789), + Trans(11, 71, 13, 789), + Trans(11, 72, 13, 789), + Trans(11, 73, 13, 789), + Trans(11, 75, 13, 789), + Trans(11, 79, 13, 789), + Trans(11, 82, 13, 789), + Trans(11, 83, 13, 789), + Trans(11, 102, 13, 789), + Trans(11, 103, 13, 789), + Trans(11, 107, 13, 789), + Trans(11, 108, 13, 789), + Trans(11, 110, 13, 789), + Trans(11, 113, 13, 789), + Trans(11, 114, 13, 789), + Trans(11, 115, 13, 789), + Trans(11, 116, 13, 789), + Trans(11, 117, 13, 789), + Trans(12, 0, 13, 789), + Trans(12, 5, 13, 789), + Trans(12, 37, 13, 789), + Trans(12, 40, 13, 789), + Trans(12, 44, 13, 789), + Trans(12, 61, 13, 789), + Trans(12, 73, 13, 789), + Trans(12, 74, 13, 789), + Trans(12, 80, 13, 789), + Trans(12, 87, 13, 789), + Trans(12, 91, 13, 789), + Trans(12, 93, 13, 789), + Trans(12, 94, 13, 789), + Trans(14, 32, 13, 789), + Trans(14, 44, 13, 789), + Trans(14, 46, 13, 789), + Trans(15, 5, 13, 789), + Trans(15, 37, 13, 789), + Trans(15, 40, 13, 789), + Trans(15, 44, 13, 789), + Trans(15, 46, 13, 789), + Trans(15, 117, 13, 789), + Trans(16, 5, 13, 789), + Trans(16, 32, 13, 789), + Trans(16, 44, 13, 789), + Trans(16, 46, 13, 789), + Trans(17, 5, 13, 789), + Trans(17, 13, 13, 789), + Trans(17, 40, 13, 789), + Trans(17, 47, 13, 789), ], k: 3, }, - /* 493 - "PortDeclarationListOpt" */ + /* 498 - "PortDeclarationListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 1, 782), - Trans(0, 44, 2, 783), - Trans(0, 46, 2, 783), + Trans(0, 32, 1, 790), + Trans(0, 44, 2, 791), + Trans(0, 46, 2, 791), ], k: 1, }, - /* 494 - "PortDeclarationOpt" */ + /* 499 - "PortDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 777), - Trans(0, 40, 1, 777), - Trans(0, 46, 2, 778), - Trans(0, 115, 1, 777), + Trans(0, 37, 1, 785), + Trans(0, 40, 1, 785), + Trans(0, 46, 2, 786), + Trans(0, 117, 1, 785), ], k: 1, }, - /* 495 - "PortTypeAbstract" */ + /* 500 - "PortTypeAbstract" */ LookaheadDFA { - prod0: 795, + prod0: 803, transitions: &[], k: 0, }, - /* 496 - "PortTypeAbstractOpt" */ + /* 501 - "PortTypeAbstractOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 28, 1, 798), Trans(0, 79, 2, 799)], + transitions: &[Trans(0, 28, 1, 806), Trans(0, 80, 2, 807)], k: 1, }, - /* 497 - "PortTypeAbstractOpt0" */ + /* 502 - "PortTypeAbstractOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 2, 797), - Trans(0, 41, 1, 796), - Trans(0, 44, 2, 797), - Trans(0, 46, 2, 797), + Trans(0, 32, 2, 805), + Trans(0, 41, 1, 804), + Trans(0, 44, 2, 805), + Trans(0, 46, 2, 805), ], k: 1, }, - /* 498 - "PortTypeConcrete" */ + /* 503 - "PortTypeConcrete" */ LookaheadDFA { - prod0: 792, + prod0: 800, transitions: &[], k: 0, }, - /* 499 - "PortTypeConcreteOpt" */ + /* 504 - "PortTypeConcreteOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 28, 1, 793), - Trans(0, 53, 2, 794), - Trans(0, 55, 2, 794), - Trans(0, 56, 2, 794), - Trans(0, 57, 2, 794), - Trans(0, 63, 2, 794), - Trans(0, 64, 2, 794), - Trans(0, 68, 2, 794), - Trans(0, 69, 2, 794), - Trans(0, 83, 2, 794), - Trans(0, 95, 2, 794), - Trans(0, 96, 2, 794), - Trans(0, 97, 2, 794), - Trans(0, 98, 2, 794), - Trans(0, 99, 2, 794), - Trans(0, 102, 2, 794), - Trans(0, 104, 2, 794), - Trans(0, 107, 2, 794), - Trans(0, 109, 2, 794), - Trans(0, 110, 2, 794), - Trans(0, 114, 2, 794), - Trans(0, 115, 2, 794), + Trans(0, 28, 1, 801), + Trans(0, 53, 2, 802), + Trans(0, 55, 2, 802), + Trans(0, 56, 2, 802), + Trans(0, 57, 2, 802), + Trans(0, 64, 2, 802), + Trans(0, 65, 2, 802), + Trans(0, 69, 2, 802), + Trans(0, 70, 2, 802), + Trans(0, 84, 2, 802), + Trans(0, 97, 2, 802), + Trans(0, 98, 2, 802), + Trans(0, 99, 2, 802), + Trans(0, 100, 2, 802), + Trans(0, 101, 2, 802), + Trans(0, 104, 2, 802), + Trans(0, 106, 2, 802), + Trans(0, 109, 2, 802), + Trans(0, 111, 2, 802), + Trans(0, 112, 2, 802), + Trans(0, 116, 2, 802), + Trans(0, 117, 2, 802), ], k: 1, }, - /* 500 - "Pub" */ + /* 505 - "Proto" */ LookaheadDFA { - prod0: 314, + prod0: 319, transitions: &[], k: 0, }, - /* 501 - "PubTerm" */ + /* 506 - "ProtoModuleDeclaration" */ LookaheadDFA { - prod0: 87, + prod0: 960, transitions: &[], k: 0, }, - /* 502 - "PubToken" */ + /* 507 - "ProtoModuleDeclarationOpt" */ LookaheadDFA { - prod0: 202, + prod0: -1, + transitions: &[Trans(0, 93, 2, 966), Trans(0, 94, 1, 965)], + k: 1, + }, + /* 508 - "ProtoModuleDeclarationOpt0" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 37, 1, 963), + Trans(0, 42, 2, 964), + Trans(0, 47, 2, 964), + ], + k: 1, + }, + /* 509 - "ProtoModuleDeclarationOpt1" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 42, 1, 961), Trans(0, 47, 2, 962)], + k: 1, + }, + /* 510 - "ProtoTerm" */ + LookaheadDFA { + prod0: 88, transitions: &[], k: 0, }, - /* 503 - "QuoteLBrace" */ + /* 511 - "ProtoToken" */ LookaheadDFA { - prod0: 256, + prod0: 205, + transitions: &[], + k: 0, + }, + /* 512 - "Pub" */ + LookaheadDFA { + prod0: 320, transitions: &[], k: 0, }, - /* 504 - "QuoteLBraceTerm" */ + /* 513 - "PubTerm" */ + LookaheadDFA { + prod0: 89, + transitions: &[], + k: 0, + }, + /* 514 - "PubToken" */ + LookaheadDFA { + prod0: 206, + transitions: &[], + k: 0, + }, + /* 515 - "QuoteLBrace" */ + LookaheadDFA { + prod0: 260, + transitions: &[], + k: 0, + }, + /* 516 - "QuoteLBraceTerm" */ LookaheadDFA { prod0: 34, transitions: &[], k: 0, }, - /* 505 - "QuoteLBraceToken" */ + /* 517 - "QuoteLBraceToken" */ LookaheadDFA { - prod0: 145, + prod0: 147, transitions: &[], k: 0, }, - /* 506 - "RAngle" */ + /* 518 - "RAngle" */ LookaheadDFA { - prod0: 264, + prod0: 268, transitions: &[], k: 0, }, - /* 507 - "RAngleTerm" */ + /* 519 - "RAngleTerm" */ LookaheadDFA { prod0: 38, transitions: &[], k: 0, }, - /* 508 - "RAngleToken" */ + /* 520 - "RAngleToken" */ LookaheadDFA { - prod0: 153, + prod0: 155, transitions: &[], k: 0, }, - /* 509 - "RBrace" */ + /* 521 - "RBrace" */ LookaheadDFA { - prod0: 265, + prod0: 269, transitions: &[], k: 0, }, - /* 510 - "RBraceTerm" */ + /* 522 - "RBraceTerm" */ LookaheadDFA { prod0: 39, transitions: &[], k: 0, }, - /* 511 - "RBraceToken" */ + /* 523 - "RBraceToken" */ LookaheadDFA { - prod0: 154, + prod0: 156, transitions: &[], k: 0, }, - /* 512 - "RBracket" */ + /* 524 - "RBracket" */ LookaheadDFA { - prod0: 266, + prod0: 270, transitions: &[], k: 0, }, - /* 513 - "RBracketTerm" */ + /* 525 - "RBracketTerm" */ LookaheadDFA { prod0: 40, transitions: &[], k: 0, }, - /* 514 - "RBracketToken" */ + /* 526 - "RBracketToken" */ LookaheadDFA { - prod0: 155, + prod0: 157, transitions: &[], k: 0, }, - /* 515 - "RParen" */ + /* 527 - "RParen" */ LookaheadDFA { - prod0: 267, + prod0: 271, transitions: &[], k: 0, }, - /* 516 - "RParenTerm" */ + /* 528 - "RParenTerm" */ LookaheadDFA { prod0: 41, transitions: &[], k: 0, }, - /* 517 - "RParenToken" */ + /* 529 - "RParenToken" */ LookaheadDFA { - prod0: 156, + prod0: 158, transitions: &[], k: 0, }, - /* 518 - "Range" */ + /* 530 - "Range" */ LookaheadDFA { - prod0: 492, + prod0: 498, transitions: &[], k: 0, }, - /* 519 - "RangeItem" */ + /* 531 - "RangeItem" */ LookaheadDFA { - prod0: 478, + prod0: 484, transitions: &[], k: 0, }, - /* 520 - "RangeList" */ + /* 532 - "RangeList" */ LookaheadDFA { - prod0: 473, + prod0: 479, transitions: &[], k: 0, }, - /* 521 - "RangeListList" */ + /* 533 - "RangeListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -11723,152 +11880,152 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 42, 4, -1), Trans(1, 44, 24, -1), Trans(1, 54, 4, -1), - Trans(1, 71, 4, -1), - Trans(1, 77, 4, -1), - Trans(1, 84, 2, -1), - Trans(1, 87, 2, -1), - Trans(1, 89, 4, -1), - Trans(1, 106, 6, -1), - Trans(1, 114, 7, -1), - Trans(1, 115, 8, -1), - Trans(2, 5, 3, 474), - Trans(2, 16, 3, 474), - Trans(2, 17, 3, 474), - Trans(2, 18, 3, 474), - Trans(2, 19, 3, 474), - Trans(2, 20, 3, 474), - Trans(2, 21, 3, 474), - Trans(2, 22, 3, 474), - Trans(2, 23, 3, 474), - Trans(2, 24, 3, 474), - Trans(2, 25, 3, 474), - Trans(2, 26, 3, 474), - Trans(2, 32, 3, 474), - Trans(2, 33, 3, 474), - Trans(2, 34, 3, 474), - Trans(2, 44, 3, 474), - Trans(2, 48, 3, 474), - Trans(2, 52, 3, 474), - Trans(4, 5, 3, 474), - Trans(4, 6, 3, 474), - Trans(4, 7, 3, 474), - Trans(4, 8, 3, 474), - Trans(4, 9, 3, 474), - Trans(4, 10, 3, 474), - Trans(4, 11, 3, 474), - Trans(4, 18, 3, 474), - Trans(4, 24, 3, 474), - Trans(4, 25, 3, 474), - Trans(4, 26, 3, 474), - Trans(4, 27, 3, 474), - Trans(4, 39, 3, 474), - Trans(4, 40, 3, 474), - Trans(4, 42, 3, 474), - Trans(4, 54, 3, 474), - Trans(4, 71, 3, 474), - Trans(4, 77, 3, 474), - Trans(4, 84, 3, 474), - Trans(4, 87, 3, 474), - Trans(4, 89, 3, 474), - Trans(4, 106, 3, 474), - Trans(4, 114, 3, 474), - Trans(4, 115, 3, 474), - Trans(5, 5, 3, 474), - Trans(5, 6, 3, 474), - Trans(5, 7, 3, 474), - Trans(5, 8, 3, 474), - Trans(5, 9, 3, 474), - Trans(5, 10, 3, 474), - Trans(5, 11, 3, 474), - Trans(5, 18, 3, 474), - Trans(5, 24, 3, 474), - Trans(5, 25, 3, 474), - Trans(5, 26, 3, 474), - Trans(5, 27, 3, 474), - Trans(5, 39, 3, 474), - Trans(5, 40, 3, 474), - Trans(5, 42, 3, 474), - Trans(5, 54, 3, 474), - Trans(5, 58, 3, 474), - Trans(5, 71, 3, 474), - Trans(5, 77, 3, 474), - Trans(5, 84, 3, 474), - Trans(5, 87, 3, 474), - Trans(5, 89, 3, 474), - Trans(5, 106, 3, 474), - Trans(5, 114, 3, 474), - Trans(5, 115, 3, 474), - Trans(6, 5, 3, 474), - Trans(6, 40, 3, 474), - Trans(7, 5, 3, 474), - Trans(7, 16, 3, 474), - Trans(7, 17, 3, 474), - Trans(7, 18, 3, 474), - Trans(7, 19, 3, 474), - Trans(7, 20, 3, 474), - Trans(7, 21, 3, 474), - Trans(7, 22, 3, 474), - Trans(7, 23, 3, 474), - Trans(7, 24, 3, 474), - Trans(7, 25, 3, 474), - Trans(7, 26, 3, 474), - Trans(7, 30, 3, 474), - Trans(7, 32, 3, 474), - Trans(7, 33, 3, 474), - Trans(7, 34, 3, 474), - Trans(7, 35, 3, 474), - Trans(7, 41, 3, 474), - Trans(7, 42, 3, 474), - Trans(7, 44, 3, 474), - Trans(7, 48, 3, 474), - Trans(7, 52, 3, 474), - Trans(8, 5, 3, 474), - Trans(8, 16, 3, 474), - Trans(8, 17, 3, 474), - Trans(8, 18, 3, 474), - Trans(8, 19, 3, 474), - Trans(8, 20, 3, 474), - Trans(8, 21, 3, 474), - Trans(8, 22, 3, 474), - Trans(8, 23, 3, 474), - Trans(8, 24, 3, 474), - Trans(8, 25, 3, 474), - Trans(8, 26, 3, 474), - Trans(8, 29, 3, 474), - Trans(8, 30, 3, 474), - Trans(8, 32, 3, 474), - Trans(8, 33, 3, 474), - Trans(8, 34, 3, 474), - Trans(8, 35, 3, 474), - Trans(8, 41, 3, 474), - Trans(8, 42, 3, 474), - Trans(8, 44, 3, 474), - Trans(8, 48, 3, 474), - Trans(8, 52, 3, 474), - Trans(9, 6, 3, 474), - Trans(9, 7, 3, 474), - Trans(9, 8, 3, 474), - Trans(9, 9, 3, 474), - Trans(9, 10, 3, 474), - Trans(9, 11, 3, 474), - Trans(9, 18, 3, 474), - Trans(9, 24, 3, 474), - Trans(9, 25, 3, 474), - Trans(9, 26, 3, 474), - Trans(9, 27, 3, 474), - Trans(9, 39, 3, 474), - Trans(9, 40, 3, 474), - Trans(9, 42, 3, 474), - Trans(9, 44, 23, 475), - Trans(9, 54, 3, 474), - Trans(9, 71, 3, 474), - Trans(9, 77, 3, 474), - Trans(9, 84, 3, 474), - Trans(9, 87, 3, 474), - Trans(9, 89, 3, 474), - Trans(9, 106, 3, 474), - Trans(9, 114, 3, 474), - Trans(9, 115, 3, 474), + Trans(1, 72, 4, -1), + Trans(1, 78, 4, -1), + Trans(1, 85, 2, -1), + Trans(1, 88, 2, -1), + Trans(1, 90, 4, -1), + Trans(1, 108, 6, -1), + Trans(1, 116, 7, -1), + Trans(1, 117, 8, -1), + Trans(2, 5, 3, 480), + Trans(2, 16, 3, 480), + Trans(2, 17, 3, 480), + Trans(2, 18, 3, 480), + Trans(2, 19, 3, 480), + Trans(2, 20, 3, 480), + Trans(2, 21, 3, 480), + Trans(2, 22, 3, 480), + Trans(2, 23, 3, 480), + Trans(2, 24, 3, 480), + Trans(2, 25, 3, 480), + Trans(2, 26, 3, 480), + Trans(2, 32, 3, 480), + Trans(2, 33, 3, 480), + Trans(2, 34, 3, 480), + Trans(2, 44, 3, 480), + Trans(2, 48, 3, 480), + Trans(2, 52, 3, 480), + Trans(4, 5, 3, 480), + Trans(4, 6, 3, 480), + Trans(4, 7, 3, 480), + Trans(4, 8, 3, 480), + Trans(4, 9, 3, 480), + Trans(4, 10, 3, 480), + Trans(4, 11, 3, 480), + Trans(4, 18, 3, 480), + Trans(4, 24, 3, 480), + Trans(4, 25, 3, 480), + Trans(4, 26, 3, 480), + Trans(4, 27, 3, 480), + Trans(4, 39, 3, 480), + Trans(4, 40, 3, 480), + Trans(4, 42, 3, 480), + Trans(4, 54, 3, 480), + Trans(4, 72, 3, 480), + Trans(4, 78, 3, 480), + Trans(4, 85, 3, 480), + Trans(4, 88, 3, 480), + Trans(4, 90, 3, 480), + Trans(4, 108, 3, 480), + Trans(4, 116, 3, 480), + Trans(4, 117, 3, 480), + Trans(5, 5, 3, 480), + Trans(5, 6, 3, 480), + Trans(5, 7, 3, 480), + Trans(5, 8, 3, 480), + Trans(5, 9, 3, 480), + Trans(5, 10, 3, 480), + Trans(5, 11, 3, 480), + Trans(5, 18, 3, 480), + Trans(5, 24, 3, 480), + Trans(5, 25, 3, 480), + Trans(5, 26, 3, 480), + Trans(5, 27, 3, 480), + Trans(5, 39, 3, 480), + Trans(5, 40, 3, 480), + Trans(5, 42, 3, 480), + Trans(5, 54, 3, 480), + Trans(5, 59, 3, 480), + Trans(5, 72, 3, 480), + Trans(5, 78, 3, 480), + Trans(5, 85, 3, 480), + Trans(5, 88, 3, 480), + Trans(5, 90, 3, 480), + Trans(5, 108, 3, 480), + Trans(5, 116, 3, 480), + Trans(5, 117, 3, 480), + Trans(6, 5, 3, 480), + Trans(6, 40, 3, 480), + Trans(7, 5, 3, 480), + Trans(7, 16, 3, 480), + Trans(7, 17, 3, 480), + Trans(7, 18, 3, 480), + Trans(7, 19, 3, 480), + Trans(7, 20, 3, 480), + Trans(7, 21, 3, 480), + Trans(7, 22, 3, 480), + Trans(7, 23, 3, 480), + Trans(7, 24, 3, 480), + Trans(7, 25, 3, 480), + Trans(7, 26, 3, 480), + Trans(7, 30, 3, 480), + Trans(7, 32, 3, 480), + Trans(7, 33, 3, 480), + Trans(7, 34, 3, 480), + Trans(7, 35, 3, 480), + Trans(7, 41, 3, 480), + Trans(7, 42, 3, 480), + Trans(7, 44, 3, 480), + Trans(7, 48, 3, 480), + Trans(7, 52, 3, 480), + Trans(8, 5, 3, 480), + Trans(8, 16, 3, 480), + Trans(8, 17, 3, 480), + Trans(8, 18, 3, 480), + Trans(8, 19, 3, 480), + Trans(8, 20, 3, 480), + Trans(8, 21, 3, 480), + Trans(8, 22, 3, 480), + Trans(8, 23, 3, 480), + Trans(8, 24, 3, 480), + Trans(8, 25, 3, 480), + Trans(8, 26, 3, 480), + Trans(8, 29, 3, 480), + Trans(8, 30, 3, 480), + Trans(8, 32, 3, 480), + Trans(8, 33, 3, 480), + Trans(8, 34, 3, 480), + Trans(8, 35, 3, 480), + Trans(8, 41, 3, 480), + Trans(8, 42, 3, 480), + Trans(8, 44, 3, 480), + Trans(8, 48, 3, 480), + Trans(8, 52, 3, 480), + Trans(9, 6, 3, 480), + Trans(9, 7, 3, 480), + Trans(9, 8, 3, 480), + Trans(9, 9, 3, 480), + Trans(9, 10, 3, 480), + Trans(9, 11, 3, 480), + Trans(9, 18, 3, 480), + Trans(9, 24, 3, 480), + Trans(9, 25, 3, 480), + Trans(9, 26, 3, 480), + Trans(9, 27, 3, 480), + Trans(9, 39, 3, 480), + Trans(9, 40, 3, 480), + Trans(9, 42, 3, 480), + Trans(9, 44, 23, 481), + Trans(9, 54, 3, 480), + Trans(9, 72, 3, 480), + Trans(9, 78, 3, 480), + Trans(9, 85, 3, 480), + Trans(9, 88, 3, 480), + Trans(9, 90, 3, 480), + Trans(9, 108, 3, 480), + Trans(9, 116, 3, 480), + Trans(9, 117, 3, 480), Trans(10, 5, 11, -1), Trans(10, 12, 12, -1), Trans(10, 14, 12, -1), @@ -11895,667 +12052,683 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(10, 47, 20, -1), Trans(10, 48, 12, -1), Trans(10, 52, 21, -1), - Trans(10, 94, 12, -1), - Trans(10, 103, 22, -1), - Trans(11, 12, 23, 475), - Trans(11, 14, 23, 475), - Trans(11, 16, 23, 475), - Trans(11, 17, 23, 475), - Trans(11, 18, 23, 475), - Trans(11, 19, 23, 475), - Trans(11, 20, 23, 475), - Trans(11, 21, 23, 475), - Trans(11, 22, 23, 475), - Trans(11, 23, 23, 475), - Trans(11, 24, 23, 475), - Trans(11, 25, 23, 475), - Trans(11, 26, 23, 475), - Trans(11, 31, 23, 475), - Trans(11, 32, 23, 475), - Trans(11, 33, 23, 475), - Trans(11, 34, 23, 475), - Trans(11, 40, 23, 475), - Trans(11, 43, 23, 475), - Trans(11, 44, 23, 475), - Trans(11, 45, 23, 475), - Trans(11, 46, 23, 475), - Trans(11, 47, 23, 475), - Trans(11, 48, 23, 475), - Trans(11, 52, 23, 475), - Trans(11, 94, 23, 475), - Trans(11, 103, 23, 475), - Trans(12, 5, 23, 475), - Trans(12, 6, 23, 475), - Trans(12, 7, 23, 475), - Trans(12, 8, 23, 475), - Trans(12, 9, 23, 475), - Trans(12, 10, 23, 475), - Trans(12, 11, 23, 475), - Trans(12, 18, 23, 475), - Trans(12, 24, 23, 475), - Trans(12, 25, 23, 475), - Trans(12, 26, 23, 475), - Trans(12, 27, 23, 475), - Trans(12, 39, 23, 475), - Trans(12, 40, 23, 475), - Trans(12, 42, 23, 475), - Trans(12, 54, 23, 475), - Trans(12, 71, 23, 475), - Trans(12, 77, 23, 475), - Trans(12, 84, 23, 475), - Trans(12, 87, 23, 475), - Trans(12, 89, 23, 475), - Trans(12, 106, 23, 475), - Trans(12, 114, 23, 475), - Trans(12, 115, 23, 475), - Trans(13, 5, 23, 475), - Trans(13, 6, 23, 475), - Trans(13, 7, 23, 475), - Trans(13, 8, 23, 475), - Trans(13, 9, 23, 475), - Trans(13, 10, 23, 475), - Trans(13, 11, 23, 475), - Trans(13, 18, 23, 475), - Trans(13, 24, 23, 475), - Trans(13, 25, 23, 475), - Trans(13, 26, 23, 475), - Trans(13, 27, 23, 475), - Trans(13, 39, 23, 475), - Trans(13, 40, 23, 475), - Trans(13, 42, 23, 475), - Trans(13, 54, 23, 475), - Trans(13, 66, 23, 475), - Trans(13, 70, 23, 475), - Trans(13, 71, 23, 475), - Trans(13, 77, 23, 475), - Trans(13, 81, 23, 475), - Trans(13, 84, 23, 475), - Trans(13, 87, 23, 475), - Trans(13, 89, 23, 475), - Trans(13, 100, 23, 475), - Trans(13, 101, 23, 475), - Trans(13, 106, 23, 475), - Trans(13, 114, 23, 475), - Trans(13, 115, 23, 475), - Trans(14, 5, 23, 475), - Trans(14, 6, 23, 475), - Trans(14, 7, 23, 475), - Trans(14, 8, 23, 475), - Trans(14, 9, 23, 475), - Trans(14, 10, 23, 475), - Trans(14, 11, 23, 475), - Trans(14, 18, 23, 475), - Trans(14, 24, 23, 475), - Trans(14, 25, 23, 475), - Trans(14, 26, 23, 475), - Trans(14, 27, 23, 475), - Trans(14, 37, 23, 475), - Trans(14, 39, 23, 475), - Trans(14, 40, 23, 475), - Trans(14, 42, 23, 475), - Trans(14, 44, 23, 475), - Trans(14, 46, 23, 475), - Trans(14, 54, 23, 475), - Trans(14, 58, 23, 475), - Trans(14, 71, 23, 475), - Trans(14, 77, 23, 475), - Trans(14, 82, 23, 475), - Trans(14, 84, 23, 475), - Trans(14, 87, 23, 475), - Trans(14, 89, 23, 475), - Trans(14, 91, 23, 475), - Trans(14, 106, 23, 475), - Trans(14, 114, 23, 475), - Trans(14, 115, 23, 475), - Trans(15, 5, 23, 475), - Trans(15, 6, 23, 475), - Trans(15, 7, 23, 475), - Trans(15, 8, 23, 475), - Trans(15, 9, 23, 475), - Trans(15, 10, 23, 475), - Trans(15, 11, 23, 475), - Trans(15, 18, 23, 475), - Trans(15, 24, 23, 475), - Trans(15, 25, 23, 475), - Trans(15, 26, 23, 475), - Trans(15, 27, 23, 475), - Trans(15, 31, 23, 475), - Trans(15, 37, 23, 475), - Trans(15, 39, 23, 475), - Trans(15, 40, 23, 475), - Trans(15, 42, 23, 475), - Trans(15, 44, 23, 475), - Trans(15, 49, 23, 475), - Trans(15, 50, 23, 475), - Trans(15, 51, 23, 475), - Trans(15, 54, 23, 475), - Trans(15, 58, 23, 475), - Trans(15, 61, 23, 475), - Trans(15, 65, 23, 475), - Trans(15, 66, 23, 475), - Trans(15, 67, 23, 475), - Trans(15, 70, 23, 475), - Trans(15, 71, 23, 475), - Trans(15, 72, 23, 475), - Trans(15, 74, 23, 475), - Trans(15, 77, 23, 475), - Trans(15, 78, 23, 475), - Trans(15, 81, 23, 475), - Trans(15, 82, 23, 475), - Trans(15, 84, 23, 475), - Trans(15, 85, 23, 475), - Trans(15, 87, 23, 475), - Trans(15, 89, 23, 475), - Trans(15, 100, 23, 475), - Trans(15, 101, 23, 475), - Trans(15, 105, 23, 475), - Trans(15, 106, 23, 475), - Trans(15, 108, 23, 475), - Trans(15, 111, 23, 475), - Trans(15, 112, 23, 475), - Trans(15, 113, 23, 475), - Trans(15, 114, 23, 475), - Trans(15, 115, 23, 475), - Trans(16, 5, 23, 475), - Trans(16, 32, 23, 475), - Trans(16, 36, 23, 475), - Trans(16, 40, 23, 475), - Trans(16, 41, 23, 475), - Trans(16, 44, 23, 475), - Trans(16, 46, 23, 475), - Trans(16, 47, 23, 475), - Trans(16, 80, 23, 475), - Trans(17, 5, 23, 475), - Trans(17, 12, 23, 475), - Trans(17, 14, 23, 475), - Trans(17, 16, 23, 475), - Trans(17, 17, 23, 475), - Trans(17, 18, 23, 475), - Trans(17, 19, 23, 475), - Trans(17, 20, 23, 475), - Trans(17, 21, 23, 475), - Trans(17, 22, 23, 475), - Trans(17, 23, 23, 475), - Trans(17, 24, 23, 475), - Trans(17, 25, 23, 475), - Trans(17, 26, 23, 475), - Trans(17, 31, 23, 475), - Trans(17, 32, 23, 475), - Trans(17, 33, 23, 475), - Trans(17, 34, 23, 475), - Trans(17, 37, 23, 475), - Trans(17, 40, 23, 475), - Trans(17, 43, 23, 475), - Trans(17, 44, 23, 475), - Trans(17, 45, 23, 475), - Trans(17, 46, 23, 475), - Trans(17, 47, 23, 475), - Trans(17, 48, 23, 475), - Trans(17, 49, 23, 475), - Trans(17, 50, 23, 475), - Trans(17, 51, 23, 475), - Trans(17, 52, 23, 475), - Trans(17, 59, 23, 475), - Trans(17, 61, 23, 475), - Trans(17, 62, 23, 475), - Trans(17, 65, 23, 475), - Trans(17, 66, 23, 475), - Trans(17, 67, 23, 475), - Trans(17, 71, 23, 475), - Trans(17, 72, 23, 475), - Trans(17, 74, 23, 475), - Trans(17, 78, 23, 475), - Trans(17, 81, 23, 475), - Trans(17, 82, 23, 475), - Trans(17, 85, 23, 475), - Trans(17, 94, 23, 475), - Trans(17, 103, 23, 475), - Trans(17, 105, 23, 475), - Trans(17, 108, 23, 475), - Trans(17, 111, 23, 475), - Trans(17, 112, 23, 475), - Trans(17, 113, 23, 475), - Trans(18, 5, 23, 475), - Trans(18, 12, 23, 475), - Trans(18, 14, 23, 475), - Trans(18, 15, 23, 475), - Trans(18, 16, 23, 475), - Trans(18, 17, 23, 475), - Trans(18, 18, 23, 475), - Trans(18, 19, 23, 475), - Trans(18, 20, 23, 475), - Trans(18, 21, 23, 475), - Trans(18, 22, 23, 475), - Trans(18, 23, 23, 475), - Trans(18, 24, 23, 475), - Trans(18, 25, 23, 475), - Trans(18, 26, 23, 475), - Trans(18, 31, 23, 475), - Trans(18, 32, 23, 475), - Trans(18, 33, 23, 475), - Trans(18, 34, 23, 475), - Trans(18, 35, 23, 475), - Trans(18, 36, 23, 475), - Trans(18, 37, 23, 475), - Trans(18, 40, 23, 475), - Trans(18, 41, 23, 475), - Trans(18, 42, 23, 475), - Trans(18, 43, 23, 475), - Trans(18, 44, 23, 475), - Trans(18, 45, 23, 475), - Trans(18, 46, 23, 475), - Trans(18, 47, 23, 475), - Trans(18, 48, 23, 475), - Trans(18, 52, 23, 475), - Trans(18, 94, 23, 475), - Trans(18, 103, 23, 475), - Trans(19, 5, 23, 475), - Trans(19, 12, 23, 475), - Trans(19, 14, 23, 475), - Trans(19, 16, 23, 475), - Trans(19, 17, 23, 475), - Trans(19, 18, 23, 475), - Trans(19, 19, 23, 475), - Trans(19, 20, 23, 475), - Trans(19, 21, 23, 475), - Trans(19, 22, 23, 475), - Trans(19, 23, 23, 475), - Trans(19, 24, 23, 475), - Trans(19, 25, 23, 475), - Trans(19, 26, 23, 475), - Trans(19, 31, 23, 475), - Trans(19, 32, 23, 475), - Trans(19, 33, 23, 475), - Trans(19, 34, 23, 475), - Trans(19, 40, 23, 475), - Trans(19, 42, 23, 475), - Trans(19, 43, 23, 475), - Trans(19, 44, 23, 475), - Trans(19, 45, 23, 475), - Trans(19, 46, 23, 475), - Trans(19, 47, 23, 475), - Trans(19, 48, 23, 475), - Trans(19, 52, 23, 475), - Trans(19, 94, 23, 475), - Trans(19, 103, 23, 475), - Trans(20, 5, 23, 475), - Trans(20, 6, 23, 475), - Trans(20, 7, 23, 475), - Trans(20, 8, 23, 475), - Trans(20, 9, 23, 475), - Trans(20, 10, 23, 475), - Trans(20, 11, 23, 475), - Trans(20, 18, 23, 475), - Trans(20, 24, 23, 475), - Trans(20, 25, 23, 475), - Trans(20, 26, 23, 475), - Trans(20, 27, 23, 475), - Trans(20, 31, 23, 475), - Trans(20, 37, 23, 475), - Trans(20, 39, 23, 475), - Trans(20, 40, 23, 475), - Trans(20, 42, 23, 475), - Trans(20, 44, 23, 475), - Trans(20, 49, 23, 475), - Trans(20, 50, 23, 475), - Trans(20, 51, 23, 475), - Trans(20, 54, 23, 475), - Trans(20, 58, 23, 475), - Trans(20, 61, 23, 475), - Trans(20, 62, 23, 475), - Trans(20, 65, 23, 475), - Trans(20, 66, 23, 475), - Trans(20, 67, 23, 475), - Trans(20, 70, 23, 475), - Trans(20, 71, 23, 475), - Trans(20, 72, 23, 475), - Trans(20, 74, 23, 475), - Trans(20, 77, 23, 475), - Trans(20, 78, 23, 475), - Trans(20, 81, 23, 475), - Trans(20, 82, 23, 475), - Trans(20, 84, 23, 475), - Trans(20, 85, 23, 475), - Trans(20, 87, 23, 475), - Trans(20, 89, 23, 475), - Trans(20, 100, 23, 475), - Trans(20, 101, 23, 475), - Trans(20, 105, 23, 475), - Trans(20, 106, 23, 475), - Trans(20, 108, 23, 475), - Trans(20, 111, 23, 475), - Trans(20, 112, 23, 475), - Trans(20, 113, 23, 475), - Trans(20, 114, 23, 475), - Trans(20, 115, 23, 475), - Trans(21, 5, 23, 475), - Trans(21, 55, 23, 475), - Trans(21, 56, 23, 475), - Trans(21, 57, 23, 475), - Trans(21, 63, 23, 475), - Trans(21, 64, 23, 475), - Trans(21, 68, 23, 475), - Trans(21, 69, 23, 475), - Trans(21, 95, 23, 475), - Trans(21, 96, 23, 475), - Trans(21, 97, 23, 475), - Trans(21, 98, 23, 475), - Trans(21, 99, 23, 475), - Trans(21, 109, 23, 475), - Trans(21, 110, 23, 475), - Trans(21, 114, 23, 475), - Trans(21, 115, 23, 475), - Trans(22, 5, 23, 475), - Trans(22, 6, 23, 475), - Trans(22, 7, 23, 475), - Trans(22, 8, 23, 475), - Trans(22, 9, 23, 475), - Trans(22, 10, 23, 475), - Trans(22, 11, 23, 475), - Trans(22, 15, 23, 475), - Trans(22, 18, 23, 475), - Trans(22, 24, 23, 475), - Trans(22, 25, 23, 475), - Trans(22, 26, 23, 475), - Trans(22, 27, 23, 475), - Trans(22, 39, 23, 475), - Trans(22, 40, 23, 475), - Trans(22, 42, 23, 475), - Trans(22, 54, 23, 475), - Trans(22, 71, 23, 475), - Trans(22, 77, 23, 475), - Trans(22, 84, 23, 475), - Trans(22, 87, 23, 475), - Trans(22, 89, 23, 475), - Trans(22, 106, 23, 475), - Trans(22, 114, 23, 475), - Trans(22, 115, 23, 475), - Trans(24, 5, 23, 475), - Trans(24, 12, 23, 475), - Trans(24, 14, 23, 475), - Trans(24, 16, 23, 475), - Trans(24, 17, 23, 475), - Trans(24, 18, 23, 475), - Trans(24, 19, 23, 475), - Trans(24, 20, 23, 475), - Trans(24, 21, 23, 475), - Trans(24, 22, 23, 475), - Trans(24, 23, 23, 475), - Trans(24, 24, 23, 475), - Trans(24, 25, 23, 475), - Trans(24, 26, 23, 475), - Trans(24, 31, 23, 475), - Trans(24, 32, 23, 475), - Trans(24, 33, 23, 475), - Trans(24, 34, 23, 475), - Trans(24, 40, 23, 475), - Trans(24, 43, 23, 475), - Trans(24, 44, 23, 475), - Trans(24, 45, 23, 475), - Trans(24, 46, 23, 475), - Trans(24, 47, 23, 475), - Trans(24, 48, 23, 475), - Trans(24, 52, 23, 475), - Trans(24, 94, 23, 475), - Trans(24, 103, 23, 475), + Trans(10, 96, 12, -1), + Trans(10, 105, 22, -1), + Trans(11, 12, 23, 481), + Trans(11, 14, 23, 481), + Trans(11, 16, 23, 481), + Trans(11, 17, 23, 481), + Trans(11, 18, 23, 481), + Trans(11, 19, 23, 481), + Trans(11, 20, 23, 481), + Trans(11, 21, 23, 481), + Trans(11, 22, 23, 481), + Trans(11, 23, 23, 481), + Trans(11, 24, 23, 481), + Trans(11, 25, 23, 481), + Trans(11, 26, 23, 481), + Trans(11, 31, 23, 481), + Trans(11, 32, 23, 481), + Trans(11, 33, 23, 481), + Trans(11, 34, 23, 481), + Trans(11, 40, 23, 481), + Trans(11, 43, 23, 481), + Trans(11, 44, 23, 481), + Trans(11, 45, 23, 481), + Trans(11, 46, 23, 481), + Trans(11, 47, 23, 481), + Trans(11, 48, 23, 481), + Trans(11, 52, 23, 481), + Trans(11, 96, 23, 481), + Trans(11, 105, 23, 481), + Trans(12, 5, 23, 481), + Trans(12, 6, 23, 481), + Trans(12, 7, 23, 481), + Trans(12, 8, 23, 481), + Trans(12, 9, 23, 481), + Trans(12, 10, 23, 481), + Trans(12, 11, 23, 481), + Trans(12, 18, 23, 481), + Trans(12, 24, 23, 481), + Trans(12, 25, 23, 481), + Trans(12, 26, 23, 481), + Trans(12, 27, 23, 481), + Trans(12, 39, 23, 481), + Trans(12, 40, 23, 481), + Trans(12, 42, 23, 481), + Trans(12, 54, 23, 481), + Trans(12, 72, 23, 481), + Trans(12, 78, 23, 481), + Trans(12, 85, 23, 481), + Trans(12, 88, 23, 481), + Trans(12, 90, 23, 481), + Trans(12, 108, 23, 481), + Trans(12, 116, 23, 481), + Trans(12, 117, 23, 481), + Trans(13, 5, 23, 481), + Trans(13, 6, 23, 481), + Trans(13, 7, 23, 481), + Trans(13, 8, 23, 481), + Trans(13, 9, 23, 481), + Trans(13, 10, 23, 481), + Trans(13, 11, 23, 481), + Trans(13, 18, 23, 481), + Trans(13, 24, 23, 481), + Trans(13, 25, 23, 481), + Trans(13, 26, 23, 481), + Trans(13, 27, 23, 481), + Trans(13, 39, 23, 481), + Trans(13, 40, 23, 481), + Trans(13, 42, 23, 481), + Trans(13, 54, 23, 481), + Trans(13, 67, 23, 481), + Trans(13, 71, 23, 481), + Trans(13, 72, 23, 481), + Trans(13, 78, 23, 481), + Trans(13, 82, 23, 481), + Trans(13, 85, 23, 481), + Trans(13, 88, 23, 481), + Trans(13, 90, 23, 481), + Trans(13, 102, 23, 481), + Trans(13, 103, 23, 481), + Trans(13, 108, 23, 481), + Trans(13, 116, 23, 481), + Trans(13, 117, 23, 481), + Trans(14, 5, 23, 481), + Trans(14, 6, 23, 481), + Trans(14, 7, 23, 481), + Trans(14, 8, 23, 481), + Trans(14, 9, 23, 481), + Trans(14, 10, 23, 481), + Trans(14, 11, 23, 481), + Trans(14, 18, 23, 481), + Trans(14, 24, 23, 481), + Trans(14, 25, 23, 481), + Trans(14, 26, 23, 481), + Trans(14, 27, 23, 481), + Trans(14, 37, 23, 481), + Trans(14, 39, 23, 481), + Trans(14, 40, 23, 481), + Trans(14, 42, 23, 481), + Trans(14, 44, 23, 481), + Trans(14, 46, 23, 481), + Trans(14, 54, 23, 481), + Trans(14, 59, 23, 481), + Trans(14, 72, 23, 481), + Trans(14, 78, 23, 481), + Trans(14, 83, 23, 481), + Trans(14, 85, 23, 481), + Trans(14, 88, 23, 481), + Trans(14, 90, 23, 481), + Trans(14, 92, 23, 481), + Trans(14, 108, 23, 481), + Trans(14, 116, 23, 481), + Trans(14, 117, 23, 481), + Trans(15, 5, 23, 481), + Trans(15, 6, 23, 481), + Trans(15, 7, 23, 481), + Trans(15, 8, 23, 481), + Trans(15, 9, 23, 481), + Trans(15, 10, 23, 481), + Trans(15, 11, 23, 481), + Trans(15, 18, 23, 481), + Trans(15, 24, 23, 481), + Trans(15, 25, 23, 481), + Trans(15, 26, 23, 481), + Trans(15, 27, 23, 481), + Trans(15, 31, 23, 481), + Trans(15, 37, 23, 481), + Trans(15, 39, 23, 481), + Trans(15, 40, 23, 481), + Trans(15, 42, 23, 481), + Trans(15, 44, 23, 481), + Trans(15, 49, 23, 481), + Trans(15, 50, 23, 481), + Trans(15, 51, 23, 481), + Trans(15, 54, 23, 481), + Trans(15, 59, 23, 481), + Trans(15, 62, 23, 481), + Trans(15, 66, 23, 481), + Trans(15, 67, 23, 481), + Trans(15, 68, 23, 481), + Trans(15, 71, 23, 481), + Trans(15, 72, 23, 481), + Trans(15, 73, 23, 481), + Trans(15, 75, 23, 481), + Trans(15, 78, 23, 481), + Trans(15, 79, 23, 481), + Trans(15, 82, 23, 481), + Trans(15, 83, 23, 481), + Trans(15, 85, 23, 481), + Trans(15, 86, 23, 481), + Trans(15, 88, 23, 481), + Trans(15, 90, 23, 481), + Trans(15, 102, 23, 481), + Trans(15, 103, 23, 481), + Trans(15, 107, 23, 481), + Trans(15, 108, 23, 481), + Trans(15, 110, 23, 481), + Trans(15, 113, 23, 481), + Trans(15, 114, 23, 481), + Trans(15, 115, 23, 481), + Trans(15, 116, 23, 481), + Trans(15, 117, 23, 481), + Trans(16, 5, 23, 481), + Trans(16, 32, 23, 481), + Trans(16, 36, 23, 481), + Trans(16, 40, 23, 481), + Trans(16, 41, 23, 481), + Trans(16, 44, 23, 481), + Trans(16, 46, 23, 481), + Trans(16, 47, 23, 481), + Trans(16, 81, 23, 481), + Trans(17, 5, 23, 481), + Trans(17, 12, 23, 481), + Trans(17, 14, 23, 481), + Trans(17, 16, 23, 481), + Trans(17, 17, 23, 481), + Trans(17, 18, 23, 481), + Trans(17, 19, 23, 481), + Trans(17, 20, 23, 481), + Trans(17, 21, 23, 481), + Trans(17, 22, 23, 481), + Trans(17, 23, 23, 481), + Trans(17, 24, 23, 481), + Trans(17, 25, 23, 481), + Trans(17, 26, 23, 481), + Trans(17, 31, 23, 481), + Trans(17, 32, 23, 481), + Trans(17, 33, 23, 481), + Trans(17, 34, 23, 481), + Trans(17, 37, 23, 481), + Trans(17, 40, 23, 481), + Trans(17, 43, 23, 481), + Trans(17, 44, 23, 481), + Trans(17, 45, 23, 481), + Trans(17, 46, 23, 481), + Trans(17, 47, 23, 481), + Trans(17, 48, 23, 481), + Trans(17, 49, 23, 481), + Trans(17, 50, 23, 481), + Trans(17, 51, 23, 481), + Trans(17, 52, 23, 481), + Trans(17, 60, 23, 481), + Trans(17, 62, 23, 481), + Trans(17, 63, 23, 481), + Trans(17, 66, 23, 481), + Trans(17, 67, 23, 481), + Trans(17, 68, 23, 481), + Trans(17, 72, 23, 481), + Trans(17, 73, 23, 481), + Trans(17, 75, 23, 481), + Trans(17, 79, 23, 481), + Trans(17, 82, 23, 481), + Trans(17, 83, 23, 481), + Trans(17, 86, 23, 481), + Trans(17, 96, 23, 481), + Trans(17, 105, 23, 481), + Trans(17, 107, 23, 481), + Trans(17, 110, 23, 481), + Trans(17, 113, 23, 481), + Trans(17, 114, 23, 481), + Trans(17, 115, 23, 481), + Trans(18, 5, 23, 481), + Trans(18, 12, 23, 481), + Trans(18, 14, 23, 481), + Trans(18, 15, 23, 481), + Trans(18, 16, 23, 481), + Trans(18, 17, 23, 481), + Trans(18, 18, 23, 481), + Trans(18, 19, 23, 481), + Trans(18, 20, 23, 481), + Trans(18, 21, 23, 481), + Trans(18, 22, 23, 481), + Trans(18, 23, 23, 481), + Trans(18, 24, 23, 481), + Trans(18, 25, 23, 481), + Trans(18, 26, 23, 481), + Trans(18, 31, 23, 481), + Trans(18, 32, 23, 481), + Trans(18, 33, 23, 481), + Trans(18, 34, 23, 481), + Trans(18, 35, 23, 481), + Trans(18, 36, 23, 481), + Trans(18, 37, 23, 481), + Trans(18, 40, 23, 481), + Trans(18, 41, 23, 481), + Trans(18, 42, 23, 481), + Trans(18, 43, 23, 481), + Trans(18, 44, 23, 481), + Trans(18, 45, 23, 481), + Trans(18, 46, 23, 481), + Trans(18, 47, 23, 481), + Trans(18, 48, 23, 481), + Trans(18, 52, 23, 481), + Trans(18, 96, 23, 481), + Trans(18, 105, 23, 481), + Trans(19, 5, 23, 481), + Trans(19, 12, 23, 481), + Trans(19, 14, 23, 481), + Trans(19, 16, 23, 481), + Trans(19, 17, 23, 481), + Trans(19, 18, 23, 481), + Trans(19, 19, 23, 481), + Trans(19, 20, 23, 481), + Trans(19, 21, 23, 481), + Trans(19, 22, 23, 481), + Trans(19, 23, 23, 481), + Trans(19, 24, 23, 481), + Trans(19, 25, 23, 481), + Trans(19, 26, 23, 481), + Trans(19, 31, 23, 481), + Trans(19, 32, 23, 481), + Trans(19, 33, 23, 481), + Trans(19, 34, 23, 481), + Trans(19, 40, 23, 481), + Trans(19, 42, 23, 481), + Trans(19, 43, 23, 481), + Trans(19, 44, 23, 481), + Trans(19, 45, 23, 481), + Trans(19, 46, 23, 481), + Trans(19, 47, 23, 481), + Trans(19, 48, 23, 481), + Trans(19, 52, 23, 481), + Trans(19, 96, 23, 481), + Trans(19, 105, 23, 481), + Trans(20, 5, 23, 481), + Trans(20, 6, 23, 481), + Trans(20, 7, 23, 481), + Trans(20, 8, 23, 481), + Trans(20, 9, 23, 481), + Trans(20, 10, 23, 481), + Trans(20, 11, 23, 481), + Trans(20, 18, 23, 481), + Trans(20, 24, 23, 481), + Trans(20, 25, 23, 481), + Trans(20, 26, 23, 481), + Trans(20, 27, 23, 481), + Trans(20, 31, 23, 481), + Trans(20, 37, 23, 481), + Trans(20, 39, 23, 481), + Trans(20, 40, 23, 481), + Trans(20, 42, 23, 481), + Trans(20, 44, 23, 481), + Trans(20, 49, 23, 481), + Trans(20, 50, 23, 481), + Trans(20, 51, 23, 481), + Trans(20, 54, 23, 481), + Trans(20, 59, 23, 481), + Trans(20, 62, 23, 481), + Trans(20, 63, 23, 481), + Trans(20, 66, 23, 481), + Trans(20, 67, 23, 481), + Trans(20, 68, 23, 481), + Trans(20, 71, 23, 481), + Trans(20, 72, 23, 481), + Trans(20, 73, 23, 481), + Trans(20, 75, 23, 481), + Trans(20, 78, 23, 481), + Trans(20, 79, 23, 481), + Trans(20, 82, 23, 481), + Trans(20, 83, 23, 481), + Trans(20, 85, 23, 481), + Trans(20, 86, 23, 481), + Trans(20, 88, 23, 481), + Trans(20, 90, 23, 481), + Trans(20, 102, 23, 481), + Trans(20, 103, 23, 481), + Trans(20, 107, 23, 481), + Trans(20, 108, 23, 481), + Trans(20, 110, 23, 481), + Trans(20, 113, 23, 481), + Trans(20, 114, 23, 481), + Trans(20, 115, 23, 481), + Trans(20, 116, 23, 481), + Trans(20, 117, 23, 481), + Trans(21, 5, 23, 481), + Trans(21, 55, 23, 481), + Trans(21, 56, 23, 481), + Trans(21, 57, 23, 481), + Trans(21, 64, 23, 481), + Trans(21, 65, 23, 481), + Trans(21, 69, 23, 481), + Trans(21, 70, 23, 481), + Trans(21, 97, 23, 481), + Trans(21, 98, 23, 481), + Trans(21, 99, 23, 481), + Trans(21, 100, 23, 481), + Trans(21, 101, 23, 481), + Trans(21, 111, 23, 481), + Trans(21, 112, 23, 481), + Trans(21, 116, 23, 481), + Trans(21, 117, 23, 481), + Trans(22, 5, 23, 481), + Trans(22, 6, 23, 481), + Trans(22, 7, 23, 481), + Trans(22, 8, 23, 481), + Trans(22, 9, 23, 481), + Trans(22, 10, 23, 481), + Trans(22, 11, 23, 481), + Trans(22, 15, 23, 481), + Trans(22, 18, 23, 481), + Trans(22, 24, 23, 481), + Trans(22, 25, 23, 481), + Trans(22, 26, 23, 481), + Trans(22, 27, 23, 481), + Trans(22, 39, 23, 481), + Trans(22, 40, 23, 481), + Trans(22, 42, 23, 481), + Trans(22, 54, 23, 481), + Trans(22, 72, 23, 481), + Trans(22, 78, 23, 481), + Trans(22, 85, 23, 481), + Trans(22, 88, 23, 481), + Trans(22, 90, 23, 481), + Trans(22, 108, 23, 481), + Trans(22, 116, 23, 481), + Trans(22, 117, 23, 481), + Trans(24, 5, 23, 481), + Trans(24, 12, 23, 481), + Trans(24, 14, 23, 481), + Trans(24, 16, 23, 481), + Trans(24, 17, 23, 481), + Trans(24, 18, 23, 481), + Trans(24, 19, 23, 481), + Trans(24, 20, 23, 481), + Trans(24, 21, 23, 481), + Trans(24, 22, 23, 481), + Trans(24, 23, 23, 481), + Trans(24, 24, 23, 481), + Trans(24, 25, 23, 481), + Trans(24, 26, 23, 481), + Trans(24, 31, 23, 481), + Trans(24, 32, 23, 481), + Trans(24, 33, 23, 481), + Trans(24, 34, 23, 481), + Trans(24, 40, 23, 481), + Trans(24, 43, 23, 481), + Trans(24, 44, 23, 481), + Trans(24, 45, 23, 481), + Trans(24, 46, 23, 481), + Trans(24, 47, 23, 481), + Trans(24, 48, 23, 481), + Trans(24, 52, 23, 481), + Trans(24, 96, 23, 481), + Trans(24, 105, 23, 481), ], k: 3, }, - /* 522 - "RangeListOpt" */ + /* 534 - "RangeListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 476), Trans(0, 44, 2, 477)], + transitions: &[Trans(0, 32, 1, 482), Trans(0, 44, 2, 483)], k: 1, }, - /* 523 - "RangeOperator" */ + /* 535 - "RangeOperator" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 33, 2, 496), Trans(0, 34, 1, 495)], + transitions: &[Trans(0, 33, 2, 502), Trans(0, 34, 1, 501)], k: 1, }, - /* 524 - "RangeOpt" */ + /* 536 - "RangeOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 2, 494), - Trans(0, 32, 2, 494), - Trans(0, 33, 1, 493), - Trans(0, 34, 1, 493), - Trans(0, 40, 2, 494), - Trans(0, 44, 2, 494), - Trans(0, 103, 2, 494), + Trans(0, 31, 2, 500), + Trans(0, 32, 2, 500), + Trans(0, 33, 1, 499), + Trans(0, 34, 1, 499), + Trans(0, 40, 2, 500), + Trans(0, 44, 2, 500), + Trans(0, 105, 2, 500), ], k: 1, }, - /* 525 - "RealNumber" */ + /* 537 - "RealNumber" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 7, 2, 343), Trans(0, 8, 1, 342)], + transitions: &[Trans(0, 7, 2, 349), Trans(0, 8, 1, 348)], k: 1, }, - /* 526 - "Ref" */ + /* 538 - "Ref" */ LookaheadDFA { - prod0: 315, + prod0: 321, transitions: &[], k: 0, }, - /* 527 - "RefTerm" */ + /* 539 - "RefTerm" */ LookaheadDFA { - prod0: 88, + prod0: 90, transitions: &[], k: 0, }, - /* 528 - "RefToken" */ + /* 540 - "RefToken" */ LookaheadDFA { - prod0: 203, + prod0: 207, transitions: &[], k: 0, }, - /* 529 - "Repeat" */ + /* 541 - "Repeat" */ LookaheadDFA { - prod0: 316, + prod0: 322, transitions: &[], k: 0, }, - /* 530 - "RepeatTerm" */ + /* 542 - "RepeatTerm" */ LookaheadDFA { - prod0: 89, + prod0: 91, transitions: &[], k: 0, }, - /* 531 - "RepeatToken" */ + /* 543 - "RepeatToken" */ LookaheadDFA { - prod0: 204, + prod0: 208, transitions: &[], k: 0, }, - /* 532 - "Reset" */ + /* 544 - "Reset" */ LookaheadDFA { - prod0: 317, + prod0: 323, transitions: &[], k: 0, }, - /* 533 - "ResetAsyncHigh" */ + /* 545 - "ResetAsyncHigh" */ LookaheadDFA { - prod0: 318, + prod0: 324, transitions: &[], k: 0, }, - /* 534 - "ResetAsyncHighTerm" */ + /* 546 - "ResetAsyncHighTerm" */ LookaheadDFA { - prod0: 91, + prod0: 93, transitions: &[], k: 0, }, - /* 535 - "ResetAsyncHighToken" */ + /* 547 - "ResetAsyncHighToken" */ LookaheadDFA { - prod0: 206, + prod0: 210, transitions: &[], k: 0, }, - /* 536 - "ResetAsyncLow" */ + /* 548 - "ResetAsyncLow" */ LookaheadDFA { - prod0: 319, + prod0: 325, transitions: &[], k: 0, }, - /* 537 - "ResetAsyncLowTerm" */ + /* 549 - "ResetAsyncLowTerm" */ LookaheadDFA { - prod0: 92, + prod0: 94, transitions: &[], k: 0, }, - /* 538 - "ResetAsyncLowToken" */ + /* 550 - "ResetAsyncLowToken" */ LookaheadDFA { - prod0: 207, + prod0: 211, transitions: &[], k: 0, }, - /* 539 - "ResetSyncHigh" */ + /* 551 - "ResetSyncHigh" */ LookaheadDFA { - prod0: 320, + prod0: 326, transitions: &[], k: 0, }, - /* 540 - "ResetSyncHighTerm" */ + /* 552 - "ResetSyncHighTerm" */ LookaheadDFA { - prod0: 93, + prod0: 95, transitions: &[], k: 0, }, - /* 541 - "ResetSyncHighToken" */ + /* 553 - "ResetSyncHighToken" */ LookaheadDFA { - prod0: 208, + prod0: 212, transitions: &[], k: 0, }, - /* 542 - "ResetSyncLow" */ + /* 554 - "ResetSyncLow" */ LookaheadDFA { - prod0: 321, + prod0: 327, transitions: &[], k: 0, }, - /* 543 - "ResetSyncLowTerm" */ + /* 555 - "ResetSyncLowTerm" */ LookaheadDFA { - prod0: 94, + prod0: 96, transitions: &[], k: 0, }, - /* 544 - "ResetSyncLowToken" */ + /* 556 - "ResetSyncLowToken" */ LookaheadDFA { - prod0: 209, + prod0: 213, transitions: &[], k: 0, }, - /* 545 - "ResetTerm" */ + /* 557 - "ResetTerm" */ LookaheadDFA { - prod0: 90, + prod0: 92, transitions: &[], k: 0, }, - /* 546 - "ResetToken" */ + /* 558 - "ResetToken" */ LookaheadDFA { - prod0: 205, + prod0: 209, transitions: &[], k: 0, }, - /* 547 - "Return" */ + /* 559 - "Return" */ LookaheadDFA { - prod0: 322, + prod0: 328, transitions: &[], k: 0, }, - /* 548 - "ReturnStatement" */ + /* 560 - "ReturnStatement" */ LookaheadDFA { - prod0: 584, + prod0: 589, transitions: &[], k: 0, }, - /* 549 - "ReturnTerm" */ + /* 561 - "ReturnTerm" */ LookaheadDFA { - prod0: 95, + prod0: 97, transitions: &[], k: 0, }, - /* 550 - "ReturnToken" */ + /* 562 - "ReturnToken" */ LookaheadDFA { - prod0: 210, + prod0: 214, transitions: &[], k: 0, }, - /* 551 - "ScalarType" */ + /* 563 - "ScalarType" */ LookaheadDFA { - prod0: 520, + prod0: 523, transitions: &[], k: 0, }, - /* 552 - "ScalarTypeGroup" */ + /* 564 - "ScalarTypeGroup" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 53, 1, 524), + Trans(0, 55, 1, 524), + Trans(0, 56, 1, 524), + Trans(0, 57, 1, 524), + Trans(0, 64, 2, 525), + Trans(0, 65, 2, 525), + Trans(0, 69, 2, 525), + Trans(0, 70, 2, 525), + Trans(0, 84, 1, 524), + Trans(0, 97, 1, 524), + Trans(0, 98, 1, 524), + Trans(0, 99, 1, 524), + Trans(0, 100, 1, 524), + Trans(0, 101, 1, 524), + Trans(0, 106, 2, 525), + Trans(0, 111, 2, 525), + Trans(0, 112, 2, 525), + Trans(0, 116, 1, 524), + Trans(0, 117, 1, 524), + ], + k: 1, + }, + /* 565 - "ScalarTypeList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 53, 1, 521), - Trans(0, 55, 1, 521), - Trans(0, 56, 1, 521), - Trans(0, 57, 1, 521), - Trans(0, 63, 2, 522), - Trans(0, 64, 2, 522), - Trans(0, 68, 2, 522), - Trans(0, 69, 2, 522), - Trans(0, 83, 1, 521), - Trans(0, 95, 1, 521), - Trans(0, 96, 1, 521), - Trans(0, 97, 1, 521), - Trans(0, 98, 1, 521), - Trans(0, 99, 1, 521), - Trans(0, 104, 2, 522), - Trans(0, 109, 2, 522), - Trans(0, 110, 2, 522), - Trans(0, 114, 1, 521), - Trans(0, 115, 1, 521), + Trans(0, 53, 2, 527), + Trans(0, 55, 2, 527), + Trans(0, 56, 2, 527), + Trans(0, 57, 2, 527), + Trans(0, 64, 2, 527), + Trans(0, 65, 2, 527), + Trans(0, 69, 2, 527), + Trans(0, 70, 2, 527), + Trans(0, 84, 2, 527), + Trans(0, 97, 2, 527), + Trans(0, 98, 2, 527), + Trans(0, 99, 2, 527), + Trans(0, 100, 2, 527), + Trans(0, 101, 2, 527), + Trans(0, 104, 1, 526), + Trans(0, 106, 2, 527), + Trans(0, 109, 1, 526), + Trans(0, 111, 2, 527), + Trans(0, 112, 2, 527), + Trans(0, 116, 2, 527), + Trans(0, 117, 2, 527), ], k: 1, }, - /* 553 - "ScalarTypeList" */ + /* 566 - "ScalarTypeOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 53, 2, 524), - Trans(0, 55, 2, 524), - Trans(0, 56, 2, 524), - Trans(0, 57, 2, 524), - Trans(0, 63, 2, 524), - Trans(0, 64, 2, 524), - Trans(0, 68, 2, 524), - Trans(0, 69, 2, 524), - Trans(0, 83, 2, 524), - Trans(0, 95, 2, 524), - Trans(0, 96, 2, 524), - Trans(0, 97, 2, 524), - Trans(0, 98, 2, 524), - Trans(0, 99, 2, 524), - Trans(0, 102, 1, 523), - Trans(0, 104, 2, 524), - Trans(0, 107, 1, 523), - Trans(0, 109, 2, 524), - Trans(0, 110, 2, 524), - Trans(0, 114, 2, 524), - Trans(0, 115, 2, 524), + Trans(0, 32, 2, 529), + Trans(0, 36, 2, 529), + Trans(0, 38, 1, 528), + Trans(0, 40, 2, 529), + Trans(0, 41, 2, 529), + Trans(0, 44, 2, 529), + Trans(0, 46, 2, 529), + Trans(0, 47, 2, 529), + Trans(0, 81, 2, 529), ], k: 1, }, - /* 554 - "ScopedIdentifier" */ + /* 567 - "ScopedIdentifier" */ LookaheadDFA { - prod0: 351, + prod0: 357, transitions: &[], k: 0, }, - /* 555 - "ScopedIdentifierGroup" */ + /* 568 - "ScopedIdentifierGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 114, 1, 352), Trans(0, 115, 2, 353)], + transitions: &[Trans(0, 116, 1, 358), Trans(0, 117, 2, 359)], k: 1, }, - /* 556 - "ScopedIdentifierList" */ + /* 569 - "ScopedIdentifierList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -12592,59 +12765,59 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(0, 47, 22, -1), Trans(0, 48, 7, -1), Trans(0, 52, 23, -1), - Trans(0, 80, 24, -1), - Trans(0, 94, 25, -1), - Trans(0, 103, 26, -1), + Trans(0, 81, 24, -1), + Trans(0, 96, 25, -1), + Trans(0, 105, 26, -1), Trans(1, 5, 4, -1), - Trans(1, 48, 43, -1), - Trans(1, 115, 2, -1), - Trans(2, 5, 3, 354), - Trans(2, 12, 3, 354), - Trans(2, 14, 3, 354), - Trans(2, 15, 3, 354), - Trans(2, 16, 3, 354), - Trans(2, 17, 3, 354), - Trans(2, 18, 3, 354), - Trans(2, 19, 3, 354), - Trans(2, 20, 3, 354), - Trans(2, 21, 3, 354), - Trans(2, 22, 3, 354), - Trans(2, 23, 3, 354), - Trans(2, 24, 3, 354), - Trans(2, 25, 3, 354), - Trans(2, 26, 3, 354), - Trans(2, 29, 3, 354), - Trans(2, 30, 3, 354), - Trans(2, 31, 3, 354), - Trans(2, 32, 3, 354), - Trans(2, 33, 3, 354), - Trans(2, 34, 3, 354), - Trans(2, 35, 3, 354), - Trans(2, 36, 3, 354), - Trans(2, 37, 3, 354), - Trans(2, 38, 3, 354), - Trans(2, 40, 3, 354), - Trans(2, 41, 3, 354), - Trans(2, 42, 3, 354), - Trans(2, 43, 3, 354), - Trans(2, 44, 3, 354), - Trans(2, 45, 3, 354), - Trans(2, 46, 3, 354), - Trans(2, 47, 3, 354), - Trans(2, 48, 3, 354), - Trans(2, 52, 3, 354), - Trans(2, 80, 3, 354), - Trans(2, 94, 3, 354), - Trans(2, 103, 3, 354), - Trans(4, 48, 27, 355), - Trans(4, 115, 3, 354), - Trans(5, 5, 65, -1), - Trans(5, 6, 66, -1), - Trans(5, 7, 66, -1), - Trans(5, 8, 66, -1), - Trans(5, 9, 66, -1), - Trans(5, 10, 66, -1), - Trans(5, 11, 66, -1), + Trans(1, 48, 44, -1), + Trans(1, 117, 2, -1), + Trans(2, 5, 3, 360), + Trans(2, 12, 3, 360), + Trans(2, 14, 3, 360), + Trans(2, 15, 3, 360), + Trans(2, 16, 3, 360), + Trans(2, 17, 3, 360), + Trans(2, 18, 3, 360), + Trans(2, 19, 3, 360), + Trans(2, 20, 3, 360), + Trans(2, 21, 3, 360), + Trans(2, 22, 3, 360), + Trans(2, 23, 3, 360), + Trans(2, 24, 3, 360), + Trans(2, 25, 3, 360), + Trans(2, 26, 3, 360), + Trans(2, 29, 3, 360), + Trans(2, 30, 3, 360), + Trans(2, 31, 3, 360), + Trans(2, 32, 3, 360), + Trans(2, 33, 3, 360), + Trans(2, 34, 3, 360), + Trans(2, 35, 3, 360), + Trans(2, 36, 3, 360), + Trans(2, 37, 3, 360), + Trans(2, 38, 3, 360), + Trans(2, 40, 3, 360), + Trans(2, 41, 3, 360), + Trans(2, 42, 3, 360), + Trans(2, 43, 3, 360), + Trans(2, 44, 3, 360), + Trans(2, 45, 3, 360), + Trans(2, 46, 3, 360), + Trans(2, 47, 3, 360), + Trans(2, 48, 3, 360), + Trans(2, 52, 3, 360), + Trans(2, 81, 3, 360), + Trans(2, 96, 3, 360), + Trans(2, 105, 3, 360), + Trans(4, 48, 27, 361), + Trans(4, 117, 3, 360), + Trans(5, 5, 75, -1), + Trans(5, 6, 76, -1), + Trans(5, 7, 76, -1), + Trans(5, 8, 76, -1), + Trans(5, 9, 76, -1), + Trans(5, 10, 76, -1), + Trans(5, 11, 76, -1), Trans(5, 18, 30, -1), Trans(5, 24, 30, -1), Trans(5, 25, 30, -1), @@ -12654,21 +12827,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(5, 40, 30, -1), Trans(5, 42, 30, -1), Trans(5, 54, 30, -1), - Trans(5, 71, 30, -1), - Trans(5, 77, 30, -1), - Trans(5, 84, 66, -1), - Trans(5, 87, 66, -1), - Trans(5, 89, 30, -1), - Trans(5, 106, 36, -1), - Trans(5, 114, 67, -1), - Trans(5, 115, 68, -1), - Trans(6, 5, 65, -1), - Trans(6, 6, 69, -1), - Trans(6, 7, 69, -1), - Trans(6, 8, 69, -1), - Trans(6, 9, 69, -1), - Trans(6, 10, 69, -1), - Trans(6, 11, 69, -1), + Trans(5, 72, 30, -1), + Trans(5, 78, 30, -1), + Trans(5, 85, 76, -1), + Trans(5, 88, 76, -1), + Trans(5, 90, 30, -1), + Trans(5, 108, 36, -1), + Trans(5, 116, 77, -1), + Trans(5, 117, 78, -1), + Trans(6, 5, 75, -1), + Trans(6, 6, 79, -1), + Trans(6, 7, 79, -1), + Trans(6, 8, 79, -1), + Trans(6, 9, 79, -1), + Trans(6, 10, 79, -1), + Trans(6, 11, 79, -1), Trans(6, 18, 30, -1), Trans(6, 24, 30, -1), Trans(6, 25, 30, -1), @@ -12678,21 +12851,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(6, 40, 30, -1), Trans(6, 42, 30, -1), Trans(6, 54, 30, -1), - Trans(6, 71, 30, -1), - Trans(6, 77, 30, -1), - Trans(6, 84, 69, -1), - Trans(6, 87, 69, -1), - Trans(6, 89, 30, -1), - Trans(6, 106, 36, -1), - Trans(6, 114, 70, -1), - Trans(6, 115, 71, -1), - Trans(7, 5, 65, -1), - Trans(7, 6, 72, -1), - Trans(7, 7, 72, -1), - Trans(7, 8, 72, -1), - Trans(7, 9, 72, -1), - Trans(7, 10, 72, -1), - Trans(7, 11, 72, -1), + Trans(6, 72, 30, -1), + Trans(6, 78, 30, -1), + Trans(6, 85, 79, -1), + Trans(6, 88, 79, -1), + Trans(6, 90, 30, -1), + Trans(6, 108, 36, -1), + Trans(6, 116, 80, -1), + Trans(6, 117, 81, -1), + Trans(7, 5, 75, -1), + Trans(7, 6, 82, -1), + Trans(7, 7, 82, -1), + Trans(7, 8, 82, -1), + Trans(7, 9, 82, -1), + Trans(7, 10, 82, -1), + Trans(7, 11, 82, -1), Trans(7, 18, 30, -1), Trans(7, 24, 30, -1), Trans(7, 25, 30, -1), @@ -12702,50 +12875,50 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(7, 40, 30, -1), Trans(7, 42, 30, -1), Trans(7, 54, 30, -1), - Trans(7, 71, 30, -1), - Trans(7, 77, 30, -1), - Trans(7, 84, 72, -1), - Trans(7, 87, 72, -1), - Trans(7, 89, 30, -1), - Trans(7, 106, 36, -1), - Trans(7, 114, 73, -1), - Trans(7, 115, 74, -1), - Trans(8, 5, 75, -1), - Trans(8, 6, 76, -1), - Trans(8, 7, 76, -1), - Trans(8, 8, 76, -1), - Trans(8, 9, 76, -1), - Trans(8, 10, 76, -1), - Trans(8, 11, 76, -1), + Trans(7, 72, 30, -1), + Trans(7, 78, 30, -1), + Trans(7, 85, 82, -1), + Trans(7, 88, 82, -1), + Trans(7, 90, 30, -1), + Trans(7, 108, 36, -1), + Trans(7, 116, 83, -1), + Trans(7, 117, 84, -1), + Trans(8, 5, 85, -1), + Trans(8, 6, 86, -1), + Trans(8, 7, 86, -1), + Trans(8, 8, 86, -1), + Trans(8, 9, 86, -1), + Trans(8, 10, 86, -1), + Trans(8, 11, 86, -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, 39, 33, -1), - Trans(8, 40, 77, -1), + Trans(8, 40, 87, -1), Trans(8, 42, 30, -1), Trans(8, 54, 30, -1), - Trans(8, 66, 31, -1), - Trans(8, 70, 36, -1), - Trans(8, 71, 30, -1), - Trans(8, 77, 30, -1), - Trans(8, 81, 31, -1), - Trans(8, 84, 76, -1), - Trans(8, 87, 76, -1), - Trans(8, 89, 30, -1), - Trans(8, 100, 30, -1), - Trans(8, 101, 43, -1), - Trans(8, 106, 36, -1), - Trans(8, 114, 78, -1), - Trans(8, 115, 79, -1), - Trans(9, 5, 80, -1), - Trans(9, 6, 81, -1), - Trans(9, 7, 81, -1), - Trans(9, 8, 81, -1), - Trans(9, 9, 81, -1), - Trans(9, 10, 81, -1), - Trans(9, 11, 81, -1), + Trans(8, 67, 31, -1), + Trans(8, 71, 36, -1), + Trans(8, 72, 30, -1), + Trans(8, 78, 30, -1), + Trans(8, 82, 31, -1), + Trans(8, 85, 86, -1), + Trans(8, 88, 86, -1), + Trans(8, 90, 30, -1), + Trans(8, 102, 30, -1), + Trans(8, 103, 44, -1), + Trans(8, 108, 36, -1), + Trans(8, 116, 88, -1), + Trans(8, 117, 89, -1), + Trans(9, 5, 90, -1), + Trans(9, 6, 91, -1), + Trans(9, 7, 91, -1), + Trans(9, 8, 91, -1), + Trans(9, 9, 91, -1), + Trans(9, 10, 91, -1), + Trans(9, 11, 91, -1), Trans(9, 18, 30, -1), Trans(9, 24, 30, -1), Trans(9, 25, 30, -1), @@ -12753,30 +12926,30 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(9, 27, 30, -1), Trans(9, 37, 32, -1), Trans(9, 39, 33, -1), - Trans(9, 40, 82, -1), + Trans(9, 40, 92, -1), Trans(9, 42, 30, -1), - Trans(9, 43, 62, -1), - Trans(9, 44, 83, -1), - Trans(9, 46, 53, -1), + Trans(9, 43, 68, -1), + Trans(9, 44, 93, -1), + Trans(9, 46, 59, -1), Trans(9, 54, 30, -1), - Trans(9, 58, 38, -1), - Trans(9, 71, 30, -1), - Trans(9, 77, 30, -1), - Trans(9, 82, 31, -1), - Trans(9, 84, 81, -1), - Trans(9, 87, 81, -1), - Trans(9, 89, 30, -1), - Trans(9, 91, 31, -1), - Trans(9, 106, 36, -1), - Trans(9, 114, 84, -1), - Trans(9, 115, 85, -1), - Trans(10, 5, 65, -1), - Trans(10, 6, 86, -1), - Trans(10, 7, 86, -1), - Trans(10, 8, 86, -1), - Trans(10, 9, 86, -1), - Trans(10, 10, 86, -1), - Trans(10, 11, 86, -1), + Trans(9, 59, 38, -1), + Trans(9, 72, 30, -1), + Trans(9, 78, 30, -1), + Trans(9, 83, 31, -1), + Trans(9, 85, 91, -1), + Trans(9, 88, 91, -1), + Trans(9, 90, 30, -1), + Trans(9, 92, 31, -1), + Trans(9, 108, 36, -1), + Trans(9, 116, 94, -1), + Trans(9, 117, 95, -1), + Trans(10, 5, 75, -1), + Trans(10, 6, 96, -1), + Trans(10, 7, 96, -1), + Trans(10, 8, 96, -1), + Trans(10, 9, 96, -1), + Trans(10, 10, 96, -1), + Trans(10, 11, 96, -1), Trans(10, 18, 30, -1), Trans(10, 24, 30, -1), Trans(10, 25, 30, -1), @@ -12786,23 +12959,23 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(10, 40, 30, -1), Trans(10, 42, 30, -1), Trans(10, 54, 30, -1), - Trans(10, 71, 30, -1), - Trans(10, 77, 30, -1), - Trans(10, 84, 86, -1), - Trans(10, 87, 86, -1), - Trans(10, 89, 30, -1), - Trans(10, 106, 36, -1), - Trans(10, 114, 87, -1), - Trans(10, 115, 88, -1), - Trans(11, 5, 126, -1), - Trans(11, 115, 127, -1), - Trans(12, 5, 65, -1), - Trans(12, 6, 89, -1), - Trans(12, 7, 89, -1), - Trans(12, 8, 89, -1), - Trans(12, 9, 89, -1), - Trans(12, 10, 89, -1), - Trans(12, 11, 89, -1), + Trans(10, 72, 30, -1), + Trans(10, 78, 30, -1), + Trans(10, 85, 96, -1), + Trans(10, 88, 96, -1), + Trans(10, 90, 30, -1), + Trans(10, 108, 36, -1), + Trans(10, 116, 97, -1), + Trans(10, 117, 98, -1), + Trans(11, 5, 128, -1), + Trans(11, 117, 129, -1), + Trans(12, 5, 75, -1), + Trans(12, 6, 99, -1), + Trans(12, 7, 100, -1), + Trans(12, 8, 100, -1), + Trans(12, 9, 100, -1), + Trans(12, 10, 100, -1), + Trans(12, 11, 100, -1), Trans(12, 18, 30, -1), Trans(12, 24, 30, -1), Trans(12, 25, 30, -1), @@ -12812,23 +12985,23 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(12, 40, 30, -1), Trans(12, 42, 30, -1), Trans(12, 54, 30, -1), - Trans(12, 71, 30, -1), - Trans(12, 77, 30, -1), - Trans(12, 84, 89, -1), - Trans(12, 87, 89, -1), - Trans(12, 89, 30, -1), - Trans(12, 106, 36, -1), - Trans(12, 114, 90, -1), - Trans(12, 115, 91, -1), - Trans(13, 5, 121, -1), - Trans(13, 42, 119, -1), - Trans(14, 5, 65, -1), - Trans(14, 6, 92, -1), - Trans(14, 7, 92, -1), - Trans(14, 8, 92, -1), - Trans(14, 9, 92, -1), - Trans(14, 10, 92, -1), - Trans(14, 11, 92, -1), + Trans(12, 72, 30, -1), + Trans(12, 78, 30, -1), + Trans(12, 85, 99, -1), + Trans(12, 88, 99, -1), + Trans(12, 90, 30, -1), + Trans(12, 108, 36, -1), + Trans(12, 116, 101, -1), + Trans(12, 117, 102, -1), + Trans(13, 5, 122, -1), + Trans(13, 42, 123, -1), + Trans(14, 5, 75, -1), + Trans(14, 6, 103, -1), + Trans(14, 7, 103, -1), + Trans(14, 8, 103, -1), + Trans(14, 9, 103, -1), + Trans(14, 10, 103, -1), + Trans(14, 11, 103, -1), Trans(14, 18, 30, -1), Trans(14, 24, 30, -1), Trans(14, 25, 30, -1), @@ -12838,21 +13011,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(14, 40, 30, -1), Trans(14, 42, 30, -1), Trans(14, 54, 30, -1), - Trans(14, 71, 30, -1), - Trans(14, 77, 30, -1), - Trans(14, 84, 92, -1), - Trans(14, 87, 92, -1), - Trans(14, 89, 30, -1), - Trans(14, 106, 36, -1), - Trans(14, 114, 93, -1), - Trans(14, 115, 94, -1), - Trans(15, 5, 95, -1), - Trans(15, 6, 96, -1), - Trans(15, 7, 96, -1), - Trans(15, 8, 96, -1), - Trans(15, 9, 96, -1), - Trans(15, 10, 96, -1), - Trans(15, 11, 96, -1), + Trans(14, 72, 30, -1), + Trans(14, 78, 30, -1), + Trans(14, 85, 103, -1), + Trans(14, 88, 103, -1), + Trans(14, 90, 30, -1), + Trans(14, 108, 36, -1), + Trans(14, 116, 104, -1), + Trans(14, 117, 105, -1), + Trans(15, 5, 47, -1), + Trans(15, 6, 48, -1), + Trans(15, 7, 48, -1), + Trans(15, 8, 48, -1), + Trans(15, 9, 48, -1), + Trans(15, 10, 48, -1), + Trans(15, 11, 48, -1), Trans(15, 18, 30, -1), Trans(15, 24, 30, -1), Trans(15, 25, 30, -1), @@ -12861,47 +13034,47 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(15, 31, 31, -1), Trans(15, 37, 32, -1), Trans(15, 39, 33, -1), - Trans(15, 40, 97, -1), + Trans(15, 40, 49, -1), Trans(15, 42, 30, -1), - Trans(15, 44, 98, -1), + Trans(15, 44, 35, -1), Trans(15, 49, 36, -1), Trans(15, 50, 37, -1), Trans(15, 51, 31, -1), Trans(15, 54, 30, -1), - Trans(15, 58, 38, -1), - Trans(15, 61, 31, -1), - Trans(15, 65, 36, -1), - Trans(15, 66, 31, -1), + Trans(15, 59, 38, -1), + Trans(15, 62, 31, -1), + Trans(15, 66, 36, -1), Trans(15, 67, 31, -1), - Trans(15, 70, 36, -1), - Trans(15, 71, 30, -1), - Trans(15, 72, 41, -1), - Trans(15, 74, 36, -1), - Trans(15, 77, 30, -1), - Trans(15, 78, 31, -1), - Trans(15, 81, 31, -1), + Trans(15, 68, 31, -1), + Trans(15, 71, 36, -1), + Trans(15, 72, 30, -1), + Trans(15, 73, 41, -1), + Trans(15, 75, 36, -1), + Trans(15, 78, 30, -1), + Trans(15, 79, 31, -1), Trans(15, 82, 31, -1), - Trans(15, 84, 96, -1), - Trans(15, 85, 31, -1), - Trans(15, 87, 96, -1), - Trans(15, 89, 30, -1), - Trans(15, 100, 30, -1), - Trans(15, 101, 43, -1), - Trans(15, 105, 31, -1), - Trans(15, 106, 36, -1), - Trans(15, 108, 31, -1), - Trans(15, 111, 31, -1), - Trans(15, 112, 39, -1), + Trans(15, 83, 31, -1), + Trans(15, 85, 48, -1), + Trans(15, 86, 31, -1), + Trans(15, 88, 48, -1), + Trans(15, 90, 30, -1), + Trans(15, 102, 30, -1), + Trans(15, 103, 44, -1), + Trans(15, 107, 31, -1), + Trans(15, 108, 36, -1), + Trans(15, 110, 31, -1), Trans(15, 113, 31, -1), - Trans(15, 114, 99, -1), - Trans(15, 115, 100, -1), - Trans(16, 5, 65, -1), - Trans(16, 6, 101, -1), - Trans(16, 7, 101, -1), - Trans(16, 8, 101, -1), - Trans(16, 9, 101, -1), - Trans(16, 10, 101, -1), - Trans(16, 11, 101, -1), + Trans(15, 114, 39, -1), + Trans(15, 115, 31, -1), + Trans(15, 116, 50, -1), + Trans(15, 117, 51, -1), + Trans(16, 5, 75, -1), + Trans(16, 6, 106, -1), + Trans(16, 7, 106, -1), + Trans(16, 8, 106, -1), + Trans(16, 9, 106, -1), + Trans(16, 10, 106, -1), + Trans(16, 11, 106, -1), Trans(16, 18, 30, -1), Trans(16, 24, 30, -1), Trans(16, 25, 30, -1), @@ -12911,21 +13084,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(16, 40, 30, -1), Trans(16, 42, 30, -1), Trans(16, 54, 30, -1), - Trans(16, 71, 30, -1), - Trans(16, 77, 30, -1), - Trans(16, 84, 101, -1), - Trans(16, 87, 101, -1), - Trans(16, 89, 30, -1), - Trans(16, 106, 36, -1), - Trans(16, 114, 102, -1), - Trans(16, 115, 103, -1), - Trans(17, 5, 104, -1), - Trans(17, 6, 105, -1), - Trans(17, 7, 105, -1), - Trans(17, 8, 105, -1), - Trans(17, 9, 105, -1), - Trans(17, 10, 105, -1), - Trans(17, 11, 105, -1), + Trans(16, 72, 30, -1), + Trans(16, 78, 30, -1), + Trans(16, 85, 106, -1), + Trans(16, 88, 106, -1), + Trans(16, 90, 30, -1), + Trans(16, 108, 36, -1), + Trans(16, 116, 107, -1), + Trans(16, 117, 108, -1), + Trans(17, 5, 109, -1), + Trans(17, 6, 110, -1), + Trans(17, 7, 110, -1), + Trans(17, 8, 110, -1), + Trans(17, 9, 110, -1), + Trans(17, 10, 110, -1), + Trans(17, 11, 110, -1), Trans(17, 18, 30, -1), Trans(17, 24, 30, -1), Trans(17, 25, 30, -1), @@ -12933,21 +13106,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(17, 27, 30, -1), Trans(17, 37, 32, -1), Trans(17, 39, 33, -1), - Trans(17, 40, 106, -1), + Trans(17, 40, 111, -1), Trans(17, 42, 30, -1), - Trans(17, 46, 72, -1), + Trans(17, 46, 82, -1), Trans(17, 54, 30, -1), - Trans(17, 71, 30, -1), - Trans(17, 77, 30, -1), - Trans(17, 84, 105, -1), - Trans(17, 87, 105, -1), - Trans(17, 89, 30, -1), - Trans(17, 106, 36, -1), - Trans(17, 114, 107, -1), - Trans(17, 115, 108, -1), - Trans(18, 5, 57, -1), + Trans(17, 72, 30, -1), + Trans(17, 78, 30, -1), + Trans(17, 85, 110, -1), + Trans(17, 88, 110, -1), + Trans(17, 90, 30, -1), + Trans(17, 108, 36, -1), + Trans(17, 116, 112, -1), + Trans(17, 117, 113, -1), + Trans(18, 5, 63, -1), Trans(18, 12, 30, -1), - Trans(18, 13, 58, -1), + Trans(18, 13, 64, -1), Trans(18, 14, 30, -1), Trans(18, 15, 30, -1), Trans(18, 16, 30, -1), @@ -12961,29 +13134,30 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(18, 24, 30, -1), Trans(18, 25, 30, -1), Trans(18, 26, 30, -1), - Trans(18, 30, 59, -1), - Trans(18, 31, 47, -1), - Trans(18, 32, 60, -1), + Trans(18, 30, 65, -1), + Trans(18, 31, 53, -1), + Trans(18, 32, 66, -1), Trans(18, 33, 30, -1), Trans(18, 34, 30, -1), Trans(18, 35, 31, -1), Trans(18, 36, 30, -1), Trans(18, 37, 39, -1), Trans(18, 38, 30, -1), - Trans(18, 40, 49, -1), + Trans(18, 40, 55, -1), Trans(18, 41, 30, -1), - Trans(18, 42, 61, -1), - Trans(18, 43, 62, -1), - Trans(18, 44, 63, -1), - Trans(18, 45, 52, -1), - Trans(18, 46, 53, -1), - Trans(18, 47, 64, -1), + Trans(18, 42, 67, -1), + Trans(18, 43, 68, -1), + Trans(18, 44, 69, -1), + Trans(18, 45, 58, -1), + Trans(18, 46, 59, -1), + Trans(18, 47, 70, -1), Trans(18, 48, 30, -1), - Trans(18, 52, 54, -1), - Trans(18, 80, 30, -1), - Trans(18, 94, 30, -1), - Trans(18, 103, 56, -1), - Trans(19, 5, 46, -1), + Trans(18, 52, 60, -1), + Trans(18, 67, 41, -1), + Trans(18, 81, 30, -1), + Trans(18, 96, 30, -1), + Trans(18, 105, 62, -1), + Trans(19, 5, 52, -1), Trans(19, 12, 30, -1), Trans(19, 14, 30, -1), Trans(19, 16, 30, -1), @@ -12997,43 +13171,43 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(19, 24, 30, -1), Trans(19, 25, 30, -1), Trans(19, 26, 30, -1), - Trans(19, 31, 47, -1), - Trans(19, 32, 48, -1), + Trans(19, 31, 53, -1), + Trans(19, 32, 54, -1), Trans(19, 33, 30, -1), Trans(19, 34, 30, -1), Trans(19, 37, 32, -1), - Trans(19, 40, 49, -1), - Trans(19, 43, 50, -1), - Trans(19, 44, 51, -1), - Trans(19, 45, 52, -1), - Trans(19, 46, 53, -1), - Trans(19, 47, 49, -1), + Trans(19, 40, 55, -1), + Trans(19, 43, 56, -1), + Trans(19, 44, 57, -1), + Trans(19, 45, 58, -1), + Trans(19, 46, 59, -1), + Trans(19, 47, 55, -1), Trans(19, 48, 30, -1), Trans(19, 49, 36, -1), Trans(19, 50, 37, -1), Trans(19, 51, 31, -1), - Trans(19, 52, 54, -1), - Trans(19, 59, 55, -1), - Trans(19, 61, 31, -1), - Trans(19, 62, 40, -1), - Trans(19, 65, 36, -1), - Trans(19, 66, 31, -1), + Trans(19, 52, 60, -1), + Trans(19, 60, 61, -1), + Trans(19, 62, 31, -1), + Trans(19, 63, 40, -1), + Trans(19, 66, 36, -1), Trans(19, 67, 31, -1), - Trans(19, 71, 30, -1), - Trans(19, 72, 41, -1), - Trans(19, 74, 36, -1), - Trans(19, 78, 31, -1), - Trans(19, 81, 31, -1), + Trans(19, 68, 31, -1), + Trans(19, 72, 30, -1), + Trans(19, 73, 41, -1), + Trans(19, 75, 36, -1), + Trans(19, 79, 31, -1), Trans(19, 82, 31, -1), - Trans(19, 85, 31, -1), - Trans(19, 94, 30, -1), - Trans(19, 103, 56, -1), - Trans(19, 105, 31, -1), - Trans(19, 108, 31, -1), - Trans(19, 111, 31, -1), - Trans(19, 112, 39, -1), + Trans(19, 83, 31, -1), + Trans(19, 86, 31, -1), + Trans(19, 96, 30, -1), + Trans(19, 105, 62, -1), + Trans(19, 107, 31, -1), + Trans(19, 110, 31, -1), Trans(19, 113, 31, -1), - Trans(20, 5, 116, -1), + Trans(19, 114, 39, -1), + Trans(19, 115, 31, -1), + Trans(20, 5, 121, -1), Trans(20, 12, 30, -1), Trans(20, 14, 30, -1), Trans(20, 15, 30, -1), @@ -13048,28 +13222,28 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(20, 24, 30, -1), Trans(20, 25, 30, -1), Trans(20, 26, 30, -1), - Trans(20, 31, 47, -1), - Trans(20, 32, 48, -1), + Trans(20, 31, 53, -1), + Trans(20, 32, 54, -1), Trans(20, 33, 30, -1), Trans(20, 34, 30, -1), Trans(20, 35, 31, -1), Trans(20, 36, 30, -1), Trans(20, 37, 39, -1), - Trans(20, 40, 117, -1), + Trans(20, 40, 72, -1), Trans(20, 41, 30, -1), - Trans(20, 42, 61, -1), - Trans(20, 43, 50, -1), - Trans(20, 44, 63, -1), - Trans(20, 45, 52, -1), - Trans(20, 46, 53, -1), - Trans(20, 47, 49, -1), + Trans(20, 42, 67, -1), + Trans(20, 43, 56, -1), + Trans(20, 44, 69, -1), + Trans(20, 45, 58, -1), + Trans(20, 46, 59, -1), + Trans(20, 47, 55, -1), Trans(20, 48, 30, -1), - Trans(20, 52, 54, -1), - Trans(20, 94, 30, -1), - Trans(20, 103, 56, -1), - Trans(21, 5, 118, -1), + Trans(20, 52, 60, -1), + Trans(20, 96, 30, -1), + Trans(20, 105, 62, -1), + Trans(21, 5, 71, -1), Trans(21, 12, 30, -1), - Trans(21, 13, 58, -1), + Trans(21, 13, 64, -1), Trans(21, 14, 30, -1), Trans(21, 16, 30, -1), Trans(21, 17, 30, -1), @@ -13082,22 +13256,22 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(21, 24, 30, -1), Trans(21, 25, 30, -1), Trans(21, 26, 30, -1), - Trans(21, 31, 47, -1), - Trans(21, 32, 48, -1), + Trans(21, 31, 53, -1), + Trans(21, 32, 54, -1), Trans(21, 33, 30, -1), Trans(21, 34, 30, -1), - Trans(21, 40, 117, -1), - Trans(21, 42, 119, -1), - Trans(21, 43, 50, -1), - Trans(21, 44, 63, -1), - Trans(21, 45, 52, -1), - Trans(21, 46, 120, -1), - Trans(21, 47, 49, -1), + Trans(21, 40, 72, -1), + Trans(21, 42, 73, -1), + Trans(21, 43, 56, -1), + Trans(21, 44, 69, -1), + Trans(21, 45, 58, -1), + Trans(21, 46, 74, -1), + Trans(21, 47, 70, -1), Trans(21, 48, 30, -1), - Trans(21, 52, 54, -1), - Trans(21, 94, 30, -1), - Trans(21, 103, 56, -1), - Trans(22, 0, 27, 355), + Trans(21, 52, 60, -1), + Trans(21, 96, 30, -1), + Trans(21, 105, 62, -1), + Trans(22, 0, 27, 361), Trans(22, 5, 28, -1), Trans(22, 6, 29, -1), Trans(22, 7, 29, -1), @@ -13120,64 +13294,65 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(22, 50, 37, -1), Trans(22, 51, 31, -1), Trans(22, 54, 30, -1), - Trans(22, 58, 38, -1), - Trans(22, 60, 39, -1), - Trans(22, 61, 31, -1), - Trans(22, 62, 40, -1), - Trans(22, 65, 36, -1), - Trans(22, 66, 31, -1), + Trans(22, 59, 38, -1), + Trans(22, 61, 39, -1), + Trans(22, 62, 31, -1), + Trans(22, 63, 40, -1), + Trans(22, 66, 36, -1), Trans(22, 67, 31, -1), - Trans(22, 70, 36, -1), - Trans(22, 71, 30, -1), - Trans(22, 72, 41, -1), - Trans(22, 73, 39, -1), - Trans(22, 74, 36, -1), - Trans(22, 77, 30, -1), - Trans(22, 78, 31, -1), + Trans(22, 68, 31, -1), + Trans(22, 71, 36, -1), + Trans(22, 72, 30, -1), + Trans(22, 73, 41, -1), + Trans(22, 74, 39, -1), + Trans(22, 75, 36, -1), + Trans(22, 78, 30, -1), Trans(22, 79, 31, -1), - Trans(22, 81, 31, -1), + Trans(22, 80, 31, -1), Trans(22, 82, 31, -1), - Trans(22, 84, 29, -1), - Trans(22, 85, 31, -1), + Trans(22, 83, 31, -1), + Trans(22, 85, 29, -1), Trans(22, 86, 31, -1), - Trans(22, 87, 29, -1), - Trans(22, 89, 30, -1), - Trans(22, 90, 31, -1), - Trans(22, 92, 42, -1), - Trans(22, 100, 30, -1), - Trans(22, 101, 43, -1), - Trans(22, 105, 31, -1), - Trans(22, 106, 36, -1), - Trans(22, 108, 31, -1), - Trans(22, 111, 31, -1), - Trans(22, 112, 39, -1), + Trans(22, 87, 31, -1), + Trans(22, 88, 29, -1), + Trans(22, 90, 30, -1), + Trans(22, 91, 31, -1), + Trans(22, 93, 42, -1), + Trans(22, 94, 43, -1), + Trans(22, 102, 30, -1), + Trans(22, 103, 44, -1), + Trans(22, 107, 31, -1), + Trans(22, 108, 36, -1), + Trans(22, 110, 31, -1), Trans(22, 113, 31, -1), - Trans(22, 114, 44, -1), - Trans(22, 115, 45, -1), - Trans(23, 5, 122, -1), - Trans(23, 55, 123, -1), - Trans(23, 56, 123, -1), - Trans(23, 57, 123, -1), - Trans(23, 63, 123, -1), - Trans(23, 64, 123, -1), - Trans(23, 68, 123, -1), - Trans(23, 69, 123, -1), - Trans(23, 95, 123, -1), - Trans(23, 96, 123, -1), - Trans(23, 97, 123, -1), - Trans(23, 98, 123, -1), - Trans(23, 99, 123, -1), - Trans(23, 109, 123, -1), - Trans(23, 110, 123, -1), - Trans(23, 114, 124, -1), - Trans(23, 115, 125, -1), - Trans(24, 5, 65, -1), - Trans(24, 6, 109, -1), - Trans(24, 7, 109, -1), - Trans(24, 8, 109, -1), - Trans(24, 9, 109, -1), - Trans(24, 10, 109, -1), - Trans(24, 11, 109, -1), + Trans(22, 114, 39, -1), + Trans(22, 115, 31, -1), + Trans(22, 116, 45, -1), + Trans(22, 117, 46, -1), + Trans(23, 5, 124, -1), + Trans(23, 55, 125, -1), + Trans(23, 56, 125, -1), + Trans(23, 57, 125, -1), + Trans(23, 64, 125, -1), + Trans(23, 65, 125, -1), + Trans(23, 69, 125, -1), + Trans(23, 70, 125, -1), + Trans(23, 97, 125, -1), + Trans(23, 98, 125, -1), + Trans(23, 99, 125, -1), + Trans(23, 100, 125, -1), + Trans(23, 101, 125, -1), + Trans(23, 111, 125, -1), + Trans(23, 112, 125, -1), + Trans(23, 116, 126, -1), + Trans(23, 117, 127, -1), + Trans(24, 5, 75, -1), + Trans(24, 6, 114, -1), + Trans(24, 7, 114, -1), + Trans(24, 8, 114, -1), + Trans(24, 9, 114, -1), + Trans(24, 10, 114, -1), + Trans(24, 11, 114, -1), Trans(24, 18, 30, -1), Trans(24, 24, 30, -1), Trans(24, 25, 30, -1), @@ -13187,21 +13362,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(24, 40, 30, -1), Trans(24, 42, 30, -1), Trans(24, 54, 30, -1), - Trans(24, 71, 30, -1), - Trans(24, 77, 30, -1), - Trans(24, 84, 109, -1), - Trans(24, 87, 109, -1), - Trans(24, 89, 30, -1), - Trans(24, 106, 36, -1), - Trans(24, 114, 110, -1), - Trans(24, 115, 111, -1), - Trans(25, 5, 65, -1), - Trans(25, 6, 112, -1), - Trans(25, 7, 112, -1), - Trans(25, 8, 112, -1), - Trans(25, 9, 112, -1), - Trans(25, 10, 112, -1), - Trans(25, 11, 112, -1), + Trans(24, 72, 30, -1), + Trans(24, 78, 30, -1), + Trans(24, 85, 114, -1), + Trans(24, 88, 114, -1), + Trans(24, 90, 30, -1), + Trans(24, 108, 36, -1), + Trans(24, 116, 115, -1), + Trans(24, 117, 116, -1), + Trans(25, 5, 75, -1), + Trans(25, 6, 117, -1), + Trans(25, 7, 117, -1), + Trans(25, 8, 117, -1), + Trans(25, 9, 117, -1), + Trans(25, 10, 117, -1), + Trans(25, 11, 117, -1), Trans(25, 18, 30, -1), Trans(25, 24, 30, -1), Trans(25, 25, 30, -1), @@ -13211,21 +13386,21 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(25, 40, 30, -1), Trans(25, 42, 30, -1), Trans(25, 54, 30, -1), - Trans(25, 71, 30, -1), - Trans(25, 77, 30, -1), - Trans(25, 84, 112, -1), - Trans(25, 87, 112, -1), - Trans(25, 89, 30, -1), - Trans(25, 106, 36, -1), - Trans(25, 114, 113, -1), - Trans(25, 115, 114, -1), - Trans(26, 5, 115, -1), - Trans(26, 6, 66, -1), - Trans(26, 7, 66, -1), - Trans(26, 8, 66, -1), - Trans(26, 9, 66, -1), - Trans(26, 10, 66, -1), - Trans(26, 11, 66, -1), + Trans(25, 72, 30, -1), + Trans(25, 78, 30, -1), + Trans(25, 85, 117, -1), + Trans(25, 88, 117, -1), + Trans(25, 90, 30, -1), + Trans(25, 108, 36, -1), + Trans(25, 116, 118, -1), + Trans(25, 117, 119, -1), + Trans(26, 5, 120, -1), + Trans(26, 6, 76, -1), + Trans(26, 7, 76, -1), + Trans(26, 8, 76, -1), + Trans(26, 9, 76, -1), + Trans(26, 10, 76, -1), + Trans(26, 11, 76, -1), Trans(26, 15, 30, -1), Trans(26, 18, 30, -1), Trans(26, 24, 30, -1), @@ -13236,2777 +13411,2764 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(26, 40, 30, -1), Trans(26, 42, 30, -1), Trans(26, 54, 30, -1), - Trans(26, 71, 30, -1), - Trans(26, 77, 30, -1), - Trans(26, 84, 66, -1), - Trans(26, 87, 66, -1), - Trans(26, 89, 30, -1), - Trans(26, 106, 36, -1), - Trans(26, 114, 67, -1), - Trans(26, 115, 68, -1), - Trans(28, 0, 27, 355), - Trans(28, 6, 27, 355), - Trans(28, 7, 27, 355), - Trans(28, 8, 27, 355), - Trans(28, 9, 27, 355), - Trans(28, 10, 27, 355), - Trans(28, 11, 27, 355), - Trans(28, 18, 27, 355), - Trans(28, 24, 27, 355), - Trans(28, 25, 27, 355), - Trans(28, 26, 27, 355), - Trans(28, 27, 27, 355), - Trans(28, 31, 27, 355), - Trans(28, 37, 27, 355), - Trans(28, 39, 27, 355), - Trans(28, 40, 27, 355), - Trans(28, 42, 27, 355), - Trans(28, 44, 27, 355), - Trans(28, 49, 27, 355), - Trans(28, 50, 27, 355), - Trans(28, 51, 27, 355), - Trans(28, 54, 27, 355), - Trans(28, 58, 27, 355), - Trans(28, 60, 27, 355), - Trans(28, 61, 27, 355), - Trans(28, 62, 27, 355), - Trans(28, 65, 27, 355), - Trans(28, 66, 27, 355), - Trans(28, 67, 27, 355), - Trans(28, 70, 27, 355), - Trans(28, 71, 27, 355), - Trans(28, 72, 27, 355), - Trans(28, 73, 27, 355), - Trans(28, 74, 27, 355), - Trans(28, 77, 27, 355), - Trans(28, 78, 27, 355), - Trans(28, 79, 27, 355), - Trans(28, 81, 27, 355), - Trans(28, 82, 27, 355), - Trans(28, 84, 27, 355), - Trans(28, 85, 27, 355), - Trans(28, 86, 27, 355), - Trans(28, 87, 27, 355), - Trans(28, 89, 27, 355), - Trans(28, 90, 27, 355), - Trans(28, 92, 27, 355), - Trans(28, 100, 27, 355), - Trans(28, 101, 27, 355), - Trans(28, 105, 27, 355), - Trans(28, 106, 27, 355), - Trans(28, 108, 27, 355), - Trans(28, 111, 27, 355), - Trans(28, 112, 27, 355), - Trans(28, 113, 27, 355), - Trans(28, 114, 27, 355), - Trans(28, 115, 27, 355), - Trans(29, 5, 27, 355), - Trans(29, 16, 27, 355), - Trans(29, 17, 27, 355), - Trans(29, 18, 27, 355), - Trans(29, 19, 27, 355), - Trans(29, 20, 27, 355), - Trans(29, 21, 27, 355), - Trans(29, 22, 27, 355), - Trans(29, 23, 27, 355), - Trans(29, 24, 27, 355), - Trans(29, 25, 27, 355), - Trans(29, 26, 27, 355), - Trans(29, 31, 27, 355), - Trans(29, 32, 27, 355), - Trans(29, 33, 27, 355), - Trans(29, 34, 27, 355), - Trans(29, 48, 27, 355), - Trans(29, 52, 27, 355), - Trans(30, 5, 27, 355), - Trans(30, 6, 27, 355), - Trans(30, 7, 27, 355), - Trans(30, 8, 27, 355), - Trans(30, 9, 27, 355), - Trans(30, 10, 27, 355), - Trans(30, 11, 27, 355), - Trans(30, 18, 27, 355), - Trans(30, 24, 27, 355), - Trans(30, 25, 27, 355), - Trans(30, 26, 27, 355), - Trans(30, 27, 27, 355), - Trans(30, 39, 27, 355), - Trans(30, 40, 27, 355), - Trans(30, 42, 27, 355), - Trans(30, 54, 27, 355), - Trans(30, 71, 27, 355), - Trans(30, 77, 27, 355), - Trans(30, 84, 27, 355), - Trans(30, 87, 27, 355), - Trans(30, 89, 27, 355), - Trans(30, 106, 27, 355), - Trans(30, 114, 27, 355), - Trans(30, 115, 27, 355), - Trans(31, 5, 27, 355), - Trans(31, 115, 27, 355), - Trans(32, 5, 27, 355), - Trans(32, 41, 27, 355), - Trans(33, 5, 27, 355), - Trans(33, 6, 27, 355), - Trans(33, 7, 27, 355), - Trans(33, 8, 27, 355), - Trans(33, 9, 27, 355), - Trans(33, 10, 27, 355), - Trans(33, 11, 27, 355), - Trans(33, 18, 27, 355), - Trans(33, 24, 27, 355), - Trans(33, 25, 27, 355), - Trans(33, 26, 27, 355), - Trans(33, 27, 27, 355), - Trans(33, 39, 27, 355), - Trans(33, 40, 27, 355), - Trans(33, 42, 27, 355), - Trans(33, 54, 27, 355), - Trans(33, 58, 27, 355), - Trans(33, 71, 27, 355), - Trans(33, 77, 27, 355), - Trans(33, 84, 27, 355), - Trans(33, 87, 27, 355), - Trans(33, 89, 27, 355), - Trans(33, 106, 27, 355), - Trans(33, 114, 27, 355), - Trans(33, 115, 27, 355), - Trans(34, 5, 27, 355), - Trans(34, 6, 27, 355), - Trans(34, 7, 27, 355), - Trans(34, 8, 27, 355), - Trans(34, 9, 27, 355), - Trans(34, 10, 27, 355), - Trans(34, 11, 27, 355), - Trans(34, 18, 27, 355), - Trans(34, 24, 27, 355), - Trans(34, 25, 27, 355), - Trans(34, 26, 27, 355), - Trans(34, 27, 27, 355), - Trans(34, 31, 27, 355), - Trans(34, 37, 27, 355), - Trans(34, 39, 27, 355), - Trans(34, 40, 27, 355), - Trans(34, 42, 27, 355), - Trans(34, 44, 27, 355), - Trans(34, 49, 27, 355), - Trans(34, 50, 27, 355), - Trans(34, 51, 27, 355), - Trans(34, 54, 27, 355), - Trans(34, 60, 27, 355), - Trans(34, 61, 27, 355), - Trans(34, 62, 27, 355), - Trans(34, 65, 27, 355), - Trans(34, 66, 27, 355), - Trans(34, 67, 27, 355), - Trans(34, 71, 27, 355), - Trans(34, 72, 27, 355), - Trans(34, 73, 27, 355), - Trans(34, 74, 27, 355), - Trans(34, 77, 27, 355), - Trans(34, 78, 27, 355), - Trans(34, 79, 27, 355), - Trans(34, 81, 27, 355), - Trans(34, 82, 27, 355), - Trans(34, 84, 27, 355), - Trans(34, 85, 27, 355), - Trans(34, 86, 27, 355), - Trans(34, 87, 27, 355), - Trans(34, 89, 27, 355), - Trans(34, 90, 27, 355), - Trans(34, 92, 27, 355), - Trans(34, 105, 27, 355), - Trans(34, 106, 27, 355), - Trans(34, 108, 27, 355), - Trans(34, 111, 27, 355), - Trans(34, 112, 27, 355), - Trans(34, 113, 27, 355), - Trans(34, 114, 27, 355), - Trans(34, 115, 27, 355), - Trans(35, 0, 27, 355), - Trans(35, 5, 27, 355), - Trans(35, 6, 27, 355), - Trans(35, 7, 27, 355), - Trans(35, 8, 27, 355), - Trans(35, 9, 27, 355), - Trans(35, 10, 27, 355), - Trans(35, 11, 27, 355), - Trans(35, 18, 27, 355), - Trans(35, 24, 27, 355), - Trans(35, 25, 27, 355), - Trans(35, 26, 27, 355), - Trans(35, 27, 27, 355), - Trans(35, 31, 27, 355), - Trans(35, 37, 27, 355), - Trans(35, 39, 27, 355), - Trans(35, 40, 27, 355), - Trans(35, 42, 27, 355), - Trans(35, 44, 27, 355), - Trans(35, 49, 27, 355), - Trans(35, 50, 27, 355), - Trans(35, 51, 27, 355), - Trans(35, 54, 27, 355), - Trans(35, 58, 27, 355), - Trans(35, 59, 27, 355), - Trans(35, 60, 27, 355), - Trans(35, 61, 27, 355), - Trans(35, 62, 27, 355), - Trans(35, 65, 27, 355), - Trans(35, 66, 27, 355), - Trans(35, 67, 27, 355), - Trans(35, 70, 27, 355), - Trans(35, 71, 27, 355), - Trans(35, 72, 27, 355), - Trans(35, 73, 27, 355), - Trans(35, 74, 27, 355), - Trans(35, 77, 27, 355), - Trans(35, 78, 27, 355), - Trans(35, 79, 27, 355), - Trans(35, 81, 27, 355), - Trans(35, 82, 27, 355), - Trans(35, 84, 27, 355), - Trans(35, 85, 27, 355), - Trans(35, 86, 27, 355), - Trans(35, 87, 27, 355), - Trans(35, 89, 27, 355), - Trans(35, 90, 27, 355), - Trans(35, 92, 27, 355), - Trans(35, 100, 27, 355), - Trans(35, 101, 27, 355), - Trans(35, 105, 27, 355), - Trans(35, 106, 27, 355), - Trans(35, 108, 27, 355), - Trans(35, 111, 27, 355), - Trans(35, 112, 27, 355), - Trans(35, 113, 27, 355), - Trans(35, 114, 27, 355), - Trans(35, 115, 27, 355), - Trans(36, 5, 27, 355), - Trans(36, 40, 27, 355), - Trans(37, 5, 27, 355), - Trans(37, 40, 27, 355), - Trans(37, 42, 27, 355), - Trans(38, 5, 27, 355), - Trans(38, 31, 27, 355), - Trans(39, 5, 27, 355), - Trans(39, 42, 27, 355), - Trans(40, 5, 27, 355), - Trans(40, 48, 27, 355), - Trans(40, 114, 27, 355), - Trans(40, 115, 27, 355), - Trans(41, 5, 27, 355), - Trans(41, 114, 27, 355), - Trans(41, 115, 27, 355), - Trans(42, 5, 27, 355), - Trans(42, 79, 27, 355), - Trans(42, 86, 27, 355), - Trans(42, 90, 27, 355), - Trans(43, 5, 27, 355), - Trans(43, 47, 27, 355), - Trans(44, 5, 27, 355), - Trans(44, 15, 27, 355), - Trans(44, 16, 27, 355), - Trans(44, 17, 27, 355), - Trans(44, 18, 27, 355), - Trans(44, 19, 27, 355), - Trans(44, 20, 27, 355), - Trans(44, 21, 27, 355), - Trans(44, 22, 27, 355), - Trans(44, 23, 27, 355), - Trans(44, 24, 27, 355), - Trans(44, 25, 27, 355), - Trans(44, 26, 27, 355), - Trans(44, 30, 27, 355), - Trans(44, 31, 27, 355), - Trans(44, 32, 27, 355), - Trans(44, 33, 27, 355), - Trans(44, 34, 27, 355), - Trans(44, 35, 27, 355), - Trans(44, 36, 27, 355), - Trans(44, 41, 27, 355), - Trans(44, 42, 27, 355), - Trans(44, 48, 27, 355), - Trans(44, 52, 27, 355), - Trans(45, 5, 27, 355), - Trans(45, 15, 27, 355), - Trans(45, 16, 27, 355), - Trans(45, 17, 27, 355), - Trans(45, 18, 27, 355), - Trans(45, 19, 27, 355), - Trans(45, 20, 27, 355), - Trans(45, 21, 27, 355), - Trans(45, 22, 27, 355), - Trans(45, 23, 27, 355), - Trans(45, 24, 27, 355), - Trans(45, 25, 27, 355), - Trans(45, 26, 27, 355), - Trans(45, 29, 27, 355), - Trans(45, 30, 27, 355), - Trans(45, 31, 27, 355), - Trans(45, 32, 27, 355), - Trans(45, 33, 27, 355), - Trans(45, 34, 27, 355), - Trans(45, 35, 27, 355), - Trans(45, 36, 27, 355), - Trans(45, 41, 27, 355), - Trans(45, 42, 27, 355), - Trans(45, 48, 27, 355), - Trans(45, 52, 27, 355), - Trans(46, 12, 27, 355), - Trans(46, 14, 27, 355), - Trans(46, 16, 27, 355), - Trans(46, 17, 27, 355), - Trans(46, 18, 27, 355), - Trans(46, 19, 27, 355), - Trans(46, 20, 27, 355), - Trans(46, 21, 27, 355), - Trans(46, 22, 27, 355), - Trans(46, 23, 27, 355), - Trans(46, 24, 27, 355), - Trans(46, 25, 27, 355), - Trans(46, 26, 27, 355), - Trans(46, 31, 27, 355), - Trans(46, 32, 27, 355), - Trans(46, 33, 27, 355), - Trans(46, 34, 27, 355), - Trans(46, 37, 27, 355), - Trans(46, 40, 27, 355), - Trans(46, 43, 27, 355), - Trans(46, 44, 27, 355), - Trans(46, 45, 27, 355), - Trans(46, 46, 27, 355), - Trans(46, 47, 27, 355), - Trans(46, 48, 27, 355), - Trans(46, 49, 27, 355), - Trans(46, 50, 27, 355), - Trans(46, 51, 27, 355), - Trans(46, 52, 27, 355), - Trans(46, 59, 27, 355), - Trans(46, 61, 27, 355), - Trans(46, 62, 27, 355), - Trans(46, 65, 27, 355), - Trans(46, 66, 27, 355), - Trans(46, 67, 27, 355), - Trans(46, 71, 27, 355), - Trans(46, 72, 27, 355), - Trans(46, 74, 27, 355), - Trans(46, 78, 27, 355), - Trans(46, 81, 27, 355), - Trans(46, 82, 27, 355), - Trans(46, 85, 27, 355), - Trans(46, 94, 27, 355), - Trans(46, 103, 27, 355), - Trans(46, 105, 27, 355), - Trans(46, 108, 27, 355), - Trans(46, 111, 27, 355), - Trans(46, 112, 27, 355), - Trans(46, 113, 27, 355), - Trans(47, 5, 27, 355), - Trans(47, 6, 27, 355), - Trans(47, 7, 27, 355), - Trans(47, 8, 27, 355), - Trans(47, 9, 27, 355), - Trans(47, 10, 27, 355), - Trans(47, 11, 27, 355), - Trans(47, 18, 27, 355), - Trans(47, 24, 27, 355), - Trans(47, 25, 27, 355), - Trans(47, 26, 27, 355), - Trans(47, 27, 27, 355), - Trans(47, 39, 27, 355), - Trans(47, 40, 27, 355), - Trans(47, 42, 27, 355), - Trans(47, 54, 27, 355), - Trans(47, 66, 27, 355), - Trans(47, 70, 27, 355), - Trans(47, 71, 27, 355), - Trans(47, 77, 27, 355), - Trans(47, 81, 27, 355), - Trans(47, 84, 27, 355), - Trans(47, 87, 27, 355), - Trans(47, 89, 27, 355), - Trans(47, 100, 27, 355), - Trans(47, 101, 27, 355), - Trans(47, 106, 27, 355), - Trans(47, 114, 27, 355), - Trans(47, 115, 27, 355), - Trans(48, 5, 27, 355), - Trans(48, 6, 27, 355), - Trans(48, 7, 27, 355), - Trans(48, 8, 27, 355), - Trans(48, 9, 27, 355), - Trans(48, 10, 27, 355), - Trans(48, 11, 27, 355), - Trans(48, 18, 27, 355), - Trans(48, 24, 27, 355), - Trans(48, 25, 27, 355), - Trans(48, 26, 27, 355), - Trans(48, 27, 27, 355), - Trans(48, 37, 27, 355), - Trans(48, 39, 27, 355), - Trans(48, 40, 27, 355), - Trans(48, 42, 27, 355), - Trans(48, 44, 27, 355), - Trans(48, 46, 27, 355), - Trans(48, 54, 27, 355), - Trans(48, 58, 27, 355), - Trans(48, 71, 27, 355), - Trans(48, 77, 27, 355), - Trans(48, 82, 27, 355), - Trans(48, 84, 27, 355), - Trans(48, 87, 27, 355), - Trans(48, 89, 27, 355), - Trans(48, 91, 27, 355), - Trans(48, 106, 27, 355), - Trans(48, 114, 27, 355), - Trans(48, 115, 27, 355), - Trans(49, 5, 27, 355), - Trans(49, 6, 27, 355), - Trans(49, 7, 27, 355), - Trans(49, 8, 27, 355), - Trans(49, 9, 27, 355), - Trans(49, 10, 27, 355), - Trans(49, 11, 27, 355), - Trans(49, 18, 27, 355), - Trans(49, 24, 27, 355), - Trans(49, 25, 27, 355), - Trans(49, 26, 27, 355), - Trans(49, 27, 27, 355), - Trans(49, 31, 27, 355), - Trans(49, 37, 27, 355), - Trans(49, 39, 27, 355), - Trans(49, 40, 27, 355), - Trans(49, 42, 27, 355), - Trans(49, 44, 27, 355), - Trans(49, 49, 27, 355), - Trans(49, 50, 27, 355), - Trans(49, 51, 27, 355), - Trans(49, 54, 27, 355), - Trans(49, 58, 27, 355), - Trans(49, 61, 27, 355), - Trans(49, 62, 27, 355), - Trans(49, 65, 27, 355), - Trans(49, 66, 27, 355), - Trans(49, 67, 27, 355), - Trans(49, 70, 27, 355), - Trans(49, 71, 27, 355), - Trans(49, 72, 27, 355), - Trans(49, 74, 27, 355), - Trans(49, 77, 27, 355), - Trans(49, 78, 27, 355), - Trans(49, 81, 27, 355), - Trans(49, 82, 27, 355), - Trans(49, 84, 27, 355), - Trans(49, 85, 27, 355), - Trans(49, 87, 27, 355), - Trans(49, 89, 27, 355), - Trans(49, 100, 27, 355), - Trans(49, 101, 27, 355), - Trans(49, 105, 27, 355), - Trans(49, 106, 27, 355), - Trans(49, 108, 27, 355), - Trans(49, 111, 27, 355), - Trans(49, 112, 27, 355), - Trans(49, 113, 27, 355), - Trans(49, 114, 27, 355), - Trans(49, 115, 27, 355), - Trans(50, 5, 27, 355), - Trans(50, 32, 27, 355), - Trans(50, 36, 27, 355), - Trans(50, 40, 27, 355), - Trans(50, 41, 27, 355), - Trans(50, 44, 27, 355), - Trans(50, 46, 27, 355), - Trans(50, 47, 27, 355), - Trans(50, 80, 27, 355), - Trans(51, 0, 27, 355), - Trans(51, 5, 27, 355), - Trans(51, 12, 27, 355), - Trans(51, 14, 27, 355), - Trans(51, 16, 27, 355), - Trans(51, 17, 27, 355), - Trans(51, 18, 27, 355), - Trans(51, 19, 27, 355), - Trans(51, 20, 27, 355), - Trans(51, 21, 27, 355), - Trans(51, 22, 27, 355), - Trans(51, 23, 27, 355), - Trans(51, 24, 27, 355), - Trans(51, 25, 27, 355), - Trans(51, 26, 27, 355), - Trans(51, 31, 27, 355), - Trans(51, 32, 27, 355), - Trans(51, 33, 27, 355), - Trans(51, 34, 27, 355), - Trans(51, 37, 27, 355), - Trans(51, 40, 27, 355), - Trans(51, 43, 27, 355), - Trans(51, 44, 27, 355), - Trans(51, 45, 27, 355), - Trans(51, 46, 27, 355), - Trans(51, 47, 27, 355), - Trans(51, 48, 27, 355), - Trans(51, 49, 27, 355), - Trans(51, 50, 27, 355), - Trans(51, 51, 27, 355), - Trans(51, 52, 27, 355), - Trans(51, 59, 27, 355), - Trans(51, 60, 27, 355), - Trans(51, 61, 27, 355), - Trans(51, 62, 27, 355), - Trans(51, 65, 27, 355), - Trans(51, 66, 27, 355), - Trans(51, 67, 27, 355), - Trans(51, 71, 27, 355), - Trans(51, 72, 27, 355), - Trans(51, 73, 27, 355), - Trans(51, 74, 27, 355), - Trans(51, 78, 27, 355), - Trans(51, 79, 27, 355), - Trans(51, 81, 27, 355), - Trans(51, 82, 27, 355), - Trans(51, 85, 27, 355), - Trans(51, 86, 27, 355), - Trans(51, 90, 27, 355), - Trans(51, 92, 27, 355), - Trans(51, 94, 27, 355), - Trans(51, 103, 27, 355), - Trans(51, 105, 27, 355), - Trans(51, 108, 27, 355), - Trans(51, 111, 27, 355), - Trans(51, 112, 27, 355), - Trans(51, 113, 27, 355), - Trans(52, 5, 27, 355), - Trans(52, 12, 27, 355), - Trans(52, 14, 27, 355), - Trans(52, 15, 27, 355), - Trans(52, 16, 27, 355), - Trans(52, 17, 27, 355), - Trans(52, 18, 27, 355), - Trans(52, 19, 27, 355), - Trans(52, 20, 27, 355), - Trans(52, 21, 27, 355), - Trans(52, 22, 27, 355), - Trans(52, 23, 27, 355), - Trans(52, 24, 27, 355), - Trans(52, 25, 27, 355), - Trans(52, 26, 27, 355), - Trans(52, 31, 27, 355), - Trans(52, 32, 27, 355), - Trans(52, 33, 27, 355), - Trans(52, 34, 27, 355), - Trans(52, 35, 27, 355), - Trans(52, 36, 27, 355), - Trans(52, 37, 27, 355), - Trans(52, 40, 27, 355), - Trans(52, 41, 27, 355), - Trans(52, 42, 27, 355), - Trans(52, 43, 27, 355), - Trans(52, 44, 27, 355), - Trans(52, 45, 27, 355), - Trans(52, 46, 27, 355), - Trans(52, 47, 27, 355), - Trans(52, 48, 27, 355), - Trans(52, 52, 27, 355), - Trans(52, 94, 27, 355), - Trans(52, 103, 27, 355), - Trans(53, 5, 27, 355), - Trans(53, 12, 27, 355), - Trans(53, 13, 27, 355), - Trans(53, 14, 27, 355), - Trans(53, 16, 27, 355), - Trans(53, 17, 27, 355), - Trans(53, 18, 27, 355), - Trans(53, 19, 27, 355), - Trans(53, 20, 27, 355), - Trans(53, 21, 27, 355), - Trans(53, 22, 27, 355), - Trans(53, 23, 27, 355), - Trans(53, 24, 27, 355), - Trans(53, 25, 27, 355), - Trans(53, 26, 27, 355), - Trans(53, 31, 27, 355), - Trans(53, 32, 27, 355), - Trans(53, 33, 27, 355), - Trans(53, 34, 27, 355), - Trans(53, 40, 27, 355), - Trans(53, 42, 27, 355), - Trans(53, 43, 27, 355), - Trans(53, 44, 27, 355), - Trans(53, 45, 27, 355), - Trans(53, 46, 27, 355), - Trans(53, 47, 27, 355), - Trans(53, 48, 27, 355), - Trans(53, 52, 27, 355), - Trans(53, 94, 27, 355), - Trans(53, 103, 27, 355), - Trans(54, 5, 27, 355), - Trans(54, 55, 27, 355), - Trans(54, 56, 27, 355), - Trans(54, 57, 27, 355), - Trans(54, 63, 27, 355), - Trans(54, 64, 27, 355), - Trans(54, 68, 27, 355), - Trans(54, 69, 27, 355), - Trans(54, 95, 27, 355), - Trans(54, 96, 27, 355), - Trans(54, 97, 27, 355), - Trans(54, 98, 27, 355), - Trans(54, 99, 27, 355), - Trans(54, 109, 27, 355), - Trans(54, 110, 27, 355), - Trans(54, 114, 27, 355), - Trans(54, 115, 27, 355), - Trans(55, 5, 27, 355), - Trans(55, 40, 27, 355), - Trans(55, 71, 27, 355), - Trans(56, 5, 27, 355), - Trans(56, 6, 27, 355), - Trans(56, 7, 27, 355), - Trans(56, 8, 27, 355), - Trans(56, 9, 27, 355), - Trans(56, 10, 27, 355), - Trans(56, 11, 27, 355), - Trans(56, 15, 27, 355), - Trans(56, 18, 27, 355), - Trans(56, 24, 27, 355), - Trans(56, 25, 27, 355), - Trans(56, 26, 27, 355), - Trans(56, 27, 27, 355), - Trans(56, 39, 27, 355), - Trans(56, 40, 27, 355), - Trans(56, 42, 27, 355), - Trans(56, 54, 27, 355), - Trans(56, 71, 27, 355), - Trans(56, 77, 27, 355), - Trans(56, 84, 27, 355), - Trans(56, 87, 27, 355), - Trans(56, 89, 27, 355), - Trans(56, 106, 27, 355), - Trans(56, 114, 27, 355), - Trans(56, 115, 27, 355), - Trans(57, 12, 27, 355), - Trans(57, 13, 27, 355), - Trans(57, 14, 27, 355), - Trans(57, 15, 27, 355), - Trans(57, 16, 27, 355), - Trans(57, 17, 27, 355), - Trans(57, 18, 27, 355), - Trans(57, 19, 27, 355), - Trans(57, 20, 27, 355), - Trans(57, 21, 27, 355), - Trans(57, 22, 27, 355), - Trans(57, 23, 27, 355), - Trans(57, 24, 27, 355), - Trans(57, 25, 27, 355), - Trans(57, 26, 27, 355), - Trans(57, 30, 27, 355), - Trans(57, 31, 27, 355), - Trans(57, 32, 27, 355), - Trans(57, 33, 27, 355), - Trans(57, 34, 27, 355), - Trans(57, 35, 27, 355), - Trans(57, 36, 27, 355), - Trans(57, 37, 27, 355), - Trans(57, 38, 27, 355), - Trans(57, 40, 27, 355), - Trans(57, 41, 27, 355), - Trans(57, 42, 27, 355), - Trans(57, 43, 27, 355), - Trans(57, 44, 27, 355), - Trans(57, 45, 27, 355), - Trans(57, 46, 27, 355), - Trans(57, 47, 27, 355), - Trans(57, 48, 27, 355), - Trans(57, 52, 27, 355), - Trans(57, 80, 27, 355), - Trans(57, 94, 27, 355), - Trans(57, 103, 27, 355), - Trans(58, 5, 27, 355), - Trans(58, 53, 27, 355), - Trans(58, 55, 27, 355), - Trans(58, 56, 27, 355), - Trans(58, 57, 27, 355), - Trans(58, 63, 27, 355), - Trans(58, 64, 27, 355), - Trans(58, 68, 27, 355), - Trans(58, 69, 27, 355), - Trans(58, 83, 27, 355), - Trans(58, 95, 27, 355), - Trans(58, 96, 27, 355), - Trans(58, 97, 27, 355), - Trans(58, 98, 27, 355), - Trans(58, 99, 27, 355), - Trans(58, 102, 27, 355), - Trans(58, 104, 27, 355), - Trans(58, 107, 27, 355), - Trans(58, 109, 27, 355), - Trans(58, 110, 27, 355), - Trans(58, 114, 27, 355), - Trans(58, 115, 27, 355), - Trans(59, 5, 27, 355), - Trans(59, 48, 27, 355), - Trans(59, 115, 27, 355), - Trans(60, 5, 27, 355), - Trans(60, 6, 27, 355), - Trans(60, 7, 27, 355), - Trans(60, 8, 27, 355), - Trans(60, 9, 27, 355), - Trans(60, 10, 27, 355), - Trans(60, 11, 27, 355), - Trans(60, 18, 27, 355), - Trans(60, 24, 27, 355), - Trans(60, 25, 27, 355), - Trans(60, 26, 27, 355), - Trans(60, 27, 27, 355), - Trans(60, 37, 27, 355), - Trans(60, 39, 27, 355), - Trans(60, 40, 27, 355), - Trans(60, 42, 27, 355), - Trans(60, 43, 27, 355), - Trans(60, 44, 27, 355), - Trans(60, 46, 27, 355), - Trans(60, 54, 27, 355), - Trans(60, 58, 27, 355), - Trans(60, 71, 27, 355), - Trans(60, 77, 27, 355), - Trans(60, 82, 27, 355), - Trans(60, 84, 27, 355), - Trans(60, 87, 27, 355), - Trans(60, 89, 27, 355), - Trans(60, 91, 27, 355), - Trans(60, 106, 27, 355), - Trans(60, 114, 27, 355), - Trans(60, 115, 27, 355), - Trans(61, 5, 27, 355), - Trans(61, 6, 27, 355), - Trans(61, 7, 27, 355), - Trans(61, 8, 27, 355), - Trans(61, 9, 27, 355), - Trans(61, 10, 27, 355), - Trans(61, 11, 27, 355), - Trans(61, 18, 27, 355), - Trans(61, 24, 27, 355), - Trans(61, 25, 27, 355), - Trans(61, 26, 27, 355), - Trans(61, 27, 27, 355), - Trans(61, 37, 27, 355), - Trans(61, 39, 27, 355), - Trans(61, 40, 27, 355), - Trans(61, 42, 27, 355), - Trans(61, 46, 27, 355), - Trans(61, 54, 27, 355), - Trans(61, 71, 27, 355), - Trans(61, 77, 27, 355), - Trans(61, 84, 27, 355), - Trans(61, 87, 27, 355), - Trans(61, 89, 27, 355), - Trans(61, 106, 27, 355), - Trans(61, 114, 27, 355), - Trans(61, 115, 27, 355), - Trans(62, 5, 27, 355), - Trans(62, 12, 27, 355), - Trans(62, 13, 27, 355), - Trans(62, 14, 27, 355), - Trans(62, 15, 27, 355), - Trans(62, 16, 27, 355), - Trans(62, 17, 27, 355), - Trans(62, 18, 27, 355), - Trans(62, 19, 27, 355), - Trans(62, 20, 27, 355), - Trans(62, 21, 27, 355), - Trans(62, 22, 27, 355), - Trans(62, 23, 27, 355), - Trans(62, 24, 27, 355), - Trans(62, 25, 27, 355), - Trans(62, 26, 27, 355), - Trans(62, 30, 27, 355), - Trans(62, 31, 27, 355), - Trans(62, 32, 27, 355), - Trans(62, 33, 27, 355), - Trans(62, 34, 27, 355), - Trans(62, 35, 27, 355), - Trans(62, 36, 27, 355), - Trans(62, 37, 27, 355), - Trans(62, 38, 27, 355), - Trans(62, 40, 27, 355), - Trans(62, 41, 27, 355), - Trans(62, 42, 27, 355), - Trans(62, 43, 27, 355), - Trans(62, 44, 27, 355), - Trans(62, 45, 27, 355), - Trans(62, 46, 27, 355), - Trans(62, 47, 27, 355), - Trans(62, 48, 27, 355), - Trans(62, 52, 27, 355), - Trans(62, 80, 27, 355), - Trans(62, 94, 27, 355), - Trans(62, 103, 27, 355), - Trans(63, 5, 27, 355), - Trans(63, 12, 27, 355), - Trans(63, 14, 27, 355), - Trans(63, 16, 27, 355), - Trans(63, 17, 27, 355), - Trans(63, 18, 27, 355), - Trans(63, 19, 27, 355), - Trans(63, 20, 27, 355), - Trans(63, 21, 27, 355), - Trans(63, 22, 27, 355), - Trans(63, 23, 27, 355), - Trans(63, 24, 27, 355), - Trans(63, 25, 27, 355), - Trans(63, 26, 27, 355), - Trans(63, 31, 27, 355), - Trans(63, 32, 27, 355), - Trans(63, 33, 27, 355), - Trans(63, 34, 27, 355), - Trans(63, 37, 27, 355), - Trans(63, 40, 27, 355), - Trans(63, 43, 27, 355), - Trans(63, 44, 27, 355), - Trans(63, 45, 27, 355), - Trans(63, 46, 27, 355), - Trans(63, 47, 27, 355), - Trans(63, 48, 27, 355), - Trans(63, 49, 27, 355), - Trans(63, 50, 27, 355), - Trans(63, 51, 27, 355), - Trans(63, 52, 27, 355), - Trans(63, 59, 27, 355), - Trans(63, 61, 27, 355), - Trans(63, 62, 27, 355), - Trans(63, 65, 27, 355), - Trans(63, 66, 27, 355), - Trans(63, 67, 27, 355), - Trans(63, 71, 27, 355), - Trans(63, 72, 27, 355), - Trans(63, 74, 27, 355), - Trans(63, 78, 27, 355), - Trans(63, 81, 27, 355), - Trans(63, 82, 27, 355), - Trans(63, 85, 27, 355), - Trans(63, 94, 27, 355), - Trans(63, 103, 27, 355), - Trans(63, 105, 27, 355), - Trans(63, 108, 27, 355), - Trans(63, 111, 27, 355), - Trans(63, 112, 27, 355), - Trans(63, 113, 27, 355), - Trans(64, 0, 27, 355), - Trans(64, 5, 27, 355), - Trans(64, 6, 27, 355), - Trans(64, 7, 27, 355), - Trans(64, 8, 27, 355), - Trans(64, 9, 27, 355), - Trans(64, 10, 27, 355), - Trans(64, 11, 27, 355), - Trans(64, 18, 27, 355), - Trans(64, 24, 27, 355), - Trans(64, 25, 27, 355), - Trans(64, 26, 27, 355), - Trans(64, 27, 27, 355), - Trans(64, 31, 27, 355), - Trans(64, 37, 27, 355), - Trans(64, 39, 27, 355), - Trans(64, 40, 27, 355), - Trans(64, 42, 27, 355), - Trans(64, 44, 27, 355), - Trans(64, 49, 27, 355), - Trans(64, 50, 27, 355), - Trans(64, 51, 27, 355), - Trans(64, 54, 27, 355), - Trans(64, 58, 27, 355), - Trans(64, 60, 27, 355), - Trans(64, 61, 27, 355), - Trans(64, 62, 27, 355), - Trans(64, 65, 27, 355), - Trans(64, 66, 27, 355), - Trans(64, 67, 27, 355), - Trans(64, 70, 27, 355), - Trans(64, 71, 27, 355), - Trans(64, 72, 27, 355), - Trans(64, 73, 27, 355), - Trans(64, 74, 27, 355), - Trans(64, 77, 27, 355), - Trans(64, 78, 27, 355), - Trans(64, 79, 27, 355), - Trans(64, 81, 27, 355), - Trans(64, 82, 27, 355), - Trans(64, 84, 27, 355), - Trans(64, 85, 27, 355), - Trans(64, 86, 27, 355), - Trans(64, 87, 27, 355), - Trans(64, 89, 27, 355), - Trans(64, 90, 27, 355), - Trans(64, 92, 27, 355), - Trans(64, 100, 27, 355), - Trans(64, 101, 27, 355), - Trans(64, 105, 27, 355), - Trans(64, 106, 27, 355), - Trans(64, 108, 27, 355), - Trans(64, 111, 27, 355), - Trans(64, 112, 27, 355), - Trans(64, 113, 27, 355), - Trans(64, 114, 27, 355), - Trans(64, 115, 27, 355), - Trans(65, 6, 27, 355), - Trans(65, 7, 27, 355), - Trans(65, 8, 27, 355), - Trans(65, 9, 27, 355), - Trans(65, 10, 27, 355), - Trans(65, 11, 27, 355), - Trans(65, 18, 27, 355), - Trans(65, 24, 27, 355), - Trans(65, 25, 27, 355), - Trans(65, 26, 27, 355), - Trans(65, 27, 27, 355), - Trans(65, 39, 27, 355), - Trans(65, 40, 27, 355), - Trans(65, 42, 27, 355), - Trans(65, 54, 27, 355), - Trans(65, 71, 27, 355), - Trans(65, 77, 27, 355), - Trans(65, 84, 27, 355), - Trans(65, 87, 27, 355), - Trans(65, 89, 27, 355), - Trans(65, 106, 27, 355), - Trans(65, 114, 27, 355), - Trans(65, 115, 27, 355), - Trans(66, 5, 27, 355), - Trans(66, 16, 27, 355), - Trans(66, 17, 27, 355), - Trans(66, 18, 27, 355), - Trans(66, 19, 27, 355), - Trans(66, 20, 27, 355), - Trans(66, 21, 27, 355), - Trans(66, 22, 27, 355), - Trans(66, 23, 27, 355), - Trans(66, 24, 27, 355), - Trans(66, 25, 27, 355), - Trans(66, 26, 27, 355), - Trans(66, 45, 27, 355), - Trans(66, 48, 27, 355), - Trans(66, 52, 27, 355), - Trans(67, 5, 27, 355), - Trans(67, 16, 27, 355), - Trans(67, 17, 27, 355), - Trans(67, 18, 27, 355), - Trans(67, 19, 27, 355), - Trans(67, 20, 27, 355), - Trans(67, 21, 27, 355), - Trans(67, 22, 27, 355), - Trans(67, 23, 27, 355), - Trans(67, 24, 27, 355), - Trans(67, 25, 27, 355), - Trans(67, 26, 27, 355), - Trans(67, 30, 27, 355), - Trans(67, 35, 27, 355), - Trans(67, 41, 27, 355), - Trans(67, 42, 27, 355), - Trans(67, 45, 27, 355), - Trans(67, 48, 27, 355), - Trans(67, 52, 27, 355), - Trans(68, 5, 27, 355), - Trans(68, 16, 27, 355), - Trans(68, 17, 27, 355), - Trans(68, 18, 27, 355), - Trans(68, 19, 27, 355), - Trans(68, 20, 27, 355), - Trans(68, 21, 27, 355), - Trans(68, 22, 27, 355), - Trans(68, 23, 27, 355), - Trans(68, 24, 27, 355), - Trans(68, 25, 27, 355), - Trans(68, 26, 27, 355), - Trans(68, 29, 27, 355), - Trans(68, 30, 27, 355), - Trans(68, 35, 27, 355), - Trans(68, 41, 27, 355), - Trans(68, 42, 27, 355), - Trans(68, 45, 27, 355), - Trans(68, 48, 27, 355), - Trans(68, 52, 27, 355), - Trans(69, 5, 27, 355), - Trans(69, 16, 27, 355), - Trans(69, 17, 27, 355), - Trans(69, 18, 27, 355), - Trans(69, 19, 27, 355), - Trans(69, 20, 27, 355), - Trans(69, 21, 27, 355), - Trans(69, 22, 27, 355), - Trans(69, 23, 27, 355), - Trans(69, 24, 27, 355), - Trans(69, 25, 27, 355), - Trans(69, 26, 27, 355), - Trans(69, 47, 27, 355), - Trans(69, 48, 27, 355), - Trans(69, 52, 27, 355), - Trans(70, 5, 27, 355), - Trans(70, 16, 27, 355), - Trans(70, 17, 27, 355), - Trans(70, 18, 27, 355), - Trans(70, 19, 27, 355), - Trans(70, 20, 27, 355), - Trans(70, 21, 27, 355), - Trans(70, 22, 27, 355), - Trans(70, 23, 27, 355), - Trans(70, 24, 27, 355), - Trans(70, 25, 27, 355), - Trans(70, 26, 27, 355), - Trans(70, 30, 27, 355), - Trans(70, 35, 27, 355), - Trans(70, 41, 27, 355), - Trans(70, 42, 27, 355), - Trans(70, 47, 27, 355), - Trans(70, 48, 27, 355), - Trans(70, 52, 27, 355), - Trans(71, 5, 27, 355), - Trans(71, 16, 27, 355), - Trans(71, 17, 27, 355), - Trans(71, 18, 27, 355), - Trans(71, 19, 27, 355), - Trans(71, 20, 27, 355), - Trans(71, 21, 27, 355), - Trans(71, 22, 27, 355), - Trans(71, 23, 27, 355), - Trans(71, 24, 27, 355), - Trans(71, 25, 27, 355), - Trans(71, 26, 27, 355), - Trans(71, 29, 27, 355), - Trans(71, 30, 27, 355), - Trans(71, 35, 27, 355), - Trans(71, 41, 27, 355), - Trans(71, 42, 27, 355), - Trans(71, 47, 27, 355), - Trans(71, 48, 27, 355), - Trans(71, 52, 27, 355), - Trans(72, 5, 27, 355), - Trans(72, 12, 27, 355), - Trans(72, 14, 27, 355), - Trans(72, 16, 27, 355), - Trans(72, 17, 27, 355), - Trans(72, 18, 27, 355), - Trans(72, 19, 27, 355), - Trans(72, 20, 27, 355), - Trans(72, 21, 27, 355), - Trans(72, 22, 27, 355), - Trans(72, 23, 27, 355), - Trans(72, 24, 27, 355), - Trans(72, 25, 27, 355), - Trans(72, 26, 27, 355), - Trans(72, 31, 27, 355), - Trans(72, 32, 27, 355), - Trans(72, 33, 27, 355), - Trans(72, 34, 27, 355), - Trans(72, 40, 27, 355), - Trans(72, 43, 27, 355), - Trans(72, 44, 27, 355), - Trans(72, 45, 27, 355), - Trans(72, 46, 27, 355), - Trans(72, 47, 27, 355), - Trans(72, 48, 27, 355), - Trans(72, 52, 27, 355), - Trans(72, 94, 27, 355), - Trans(72, 103, 27, 355), - Trans(73, 5, 27, 355), - Trans(73, 12, 27, 355), - Trans(73, 14, 27, 355), - Trans(73, 16, 27, 355), - Trans(73, 17, 27, 355), - Trans(73, 18, 27, 355), - Trans(73, 19, 27, 355), - Trans(73, 20, 27, 355), - Trans(73, 21, 27, 355), - Trans(73, 22, 27, 355), - Trans(73, 23, 27, 355), - Trans(73, 24, 27, 355), - Trans(73, 25, 27, 355), - Trans(73, 26, 27, 355), - Trans(73, 30, 27, 355), - Trans(73, 31, 27, 355), - Trans(73, 32, 27, 355), - Trans(73, 33, 27, 355), - Trans(73, 34, 27, 355), - Trans(73, 35, 27, 355), - Trans(73, 40, 27, 355), - Trans(73, 41, 27, 355), - Trans(73, 42, 27, 355), - Trans(73, 43, 27, 355), - Trans(73, 44, 27, 355), - Trans(73, 45, 27, 355), - Trans(73, 46, 27, 355), - Trans(73, 47, 27, 355), - Trans(73, 48, 27, 355), - Trans(73, 52, 27, 355), - Trans(73, 94, 27, 355), - Trans(73, 103, 27, 355), - Trans(74, 5, 27, 355), - Trans(74, 12, 27, 355), - Trans(74, 14, 27, 355), - Trans(74, 16, 27, 355), - Trans(74, 17, 27, 355), - Trans(74, 18, 27, 355), - Trans(74, 19, 27, 355), - Trans(74, 20, 27, 355), - Trans(74, 21, 27, 355), - Trans(74, 22, 27, 355), - Trans(74, 23, 27, 355), - Trans(74, 24, 27, 355), - Trans(74, 25, 27, 355), - Trans(74, 26, 27, 355), - Trans(74, 29, 27, 355), - Trans(74, 30, 27, 355), - Trans(74, 31, 27, 355), - Trans(74, 32, 27, 355), - Trans(74, 33, 27, 355), - Trans(74, 34, 27, 355), - Trans(74, 35, 27, 355), - Trans(74, 40, 27, 355), - Trans(74, 41, 27, 355), - Trans(74, 42, 27, 355), - Trans(74, 43, 27, 355), - Trans(74, 44, 27, 355), - Trans(74, 45, 27, 355), - Trans(74, 46, 27, 355), - Trans(74, 47, 27, 355), - Trans(74, 48, 27, 355), - Trans(74, 52, 27, 355), - Trans(74, 94, 27, 355), - Trans(74, 103, 27, 355), - Trans(75, 6, 27, 355), - Trans(75, 7, 27, 355), - Trans(75, 8, 27, 355), - Trans(75, 9, 27, 355), - Trans(75, 10, 27, 355), - Trans(75, 11, 27, 355), - Trans(75, 18, 27, 355), - Trans(75, 24, 27, 355), - Trans(75, 25, 27, 355), - Trans(75, 26, 27, 355), - Trans(75, 27, 27, 355), - Trans(75, 39, 27, 355), - Trans(75, 40, 27, 355), - Trans(75, 42, 27, 355), - Trans(75, 54, 27, 355), - Trans(75, 66, 27, 355), - Trans(75, 70, 27, 355), - Trans(75, 71, 27, 355), - Trans(75, 77, 27, 355), - Trans(75, 81, 27, 355), - Trans(75, 84, 27, 355), - Trans(75, 87, 27, 355), - Trans(75, 89, 27, 355), - Trans(75, 100, 27, 355), - Trans(75, 101, 27, 355), - Trans(75, 106, 27, 355), - Trans(75, 114, 27, 355), - Trans(75, 115, 27, 355), - Trans(76, 5, 27, 355), - Trans(76, 16, 27, 355), - Trans(76, 17, 27, 355), - Trans(76, 18, 27, 355), - Trans(76, 19, 27, 355), - Trans(76, 20, 27, 355), - Trans(76, 21, 27, 355), - Trans(76, 22, 27, 355), - Trans(76, 23, 27, 355), - Trans(76, 24, 27, 355), - Trans(76, 25, 27, 355), - Trans(76, 26, 27, 355), - Trans(76, 32, 27, 355), - Trans(76, 45, 27, 355), - Trans(76, 48, 27, 355), - Trans(76, 52, 27, 355), - Trans(77, 5, 27, 355), - Trans(77, 6, 27, 355), - Trans(77, 7, 27, 355), - Trans(77, 8, 27, 355), - Trans(77, 9, 27, 355), - Trans(77, 10, 27, 355), - Trans(77, 11, 27, 355), - Trans(77, 18, 27, 355), - Trans(77, 24, 27, 355), - Trans(77, 25, 27, 355), - Trans(77, 26, 27, 355), - Trans(77, 27, 27, 355), - Trans(77, 39, 27, 355), - Trans(77, 40, 27, 355), - Trans(77, 42, 27, 355), - Trans(77, 44, 27, 355), - Trans(77, 54, 27, 355), - Trans(77, 66, 27, 355), - Trans(77, 70, 27, 355), - Trans(77, 71, 27, 355), - Trans(77, 77, 27, 355), - Trans(77, 81, 27, 355), - Trans(77, 84, 27, 355), - Trans(77, 87, 27, 355), - Trans(77, 89, 27, 355), - Trans(77, 100, 27, 355), - Trans(77, 101, 27, 355), - Trans(77, 106, 27, 355), - Trans(77, 114, 27, 355), - Trans(77, 115, 27, 355), - Trans(78, 5, 27, 355), - Trans(78, 15, 27, 355), - Trans(78, 16, 27, 355), - Trans(78, 17, 27, 355), - Trans(78, 18, 27, 355), - Trans(78, 19, 27, 355), - Trans(78, 20, 27, 355), - Trans(78, 21, 27, 355), - Trans(78, 22, 27, 355), - Trans(78, 23, 27, 355), - Trans(78, 24, 27, 355), - Trans(78, 25, 27, 355), - Trans(78, 26, 27, 355), - Trans(78, 30, 27, 355), - Trans(78, 32, 27, 355), - Trans(78, 35, 27, 355), - Trans(78, 36, 27, 355), - Trans(78, 41, 27, 355), - Trans(78, 42, 27, 355), - Trans(78, 45, 27, 355), - Trans(78, 48, 27, 355), - Trans(78, 52, 27, 355), - Trans(79, 5, 27, 355), - Trans(79, 15, 27, 355), - Trans(79, 16, 27, 355), - Trans(79, 17, 27, 355), - Trans(79, 18, 27, 355), - Trans(79, 19, 27, 355), - Trans(79, 20, 27, 355), - Trans(79, 21, 27, 355), - Trans(79, 22, 27, 355), - Trans(79, 23, 27, 355), - Trans(79, 24, 27, 355), - Trans(79, 25, 27, 355), - Trans(79, 26, 27, 355), - Trans(79, 29, 27, 355), - Trans(79, 30, 27, 355), - Trans(79, 32, 27, 355), - Trans(79, 35, 27, 355), - Trans(79, 36, 27, 355), - Trans(79, 40, 27, 355), - Trans(79, 41, 27, 355), - Trans(79, 42, 27, 355), - Trans(79, 45, 27, 355), - Trans(79, 48, 27, 355), - Trans(79, 52, 27, 355), - Trans(80, 6, 27, 355), - Trans(80, 7, 27, 355), - Trans(80, 8, 27, 355), - Trans(80, 9, 27, 355), - Trans(80, 10, 27, 355), - Trans(80, 11, 27, 355), - Trans(80, 18, 27, 355), - Trans(80, 24, 27, 355), - Trans(80, 25, 27, 355), - Trans(80, 26, 27, 355), - Trans(80, 27, 27, 355), - Trans(80, 37, 27, 355), - Trans(80, 39, 27, 355), - Trans(80, 40, 27, 355), - Trans(80, 42, 27, 355), - Trans(80, 43, 27, 355), - Trans(80, 44, 27, 355), - Trans(80, 46, 27, 355), - Trans(80, 54, 27, 355), - Trans(80, 58, 27, 355), - Trans(80, 71, 27, 355), - Trans(80, 77, 27, 355), - Trans(80, 82, 27, 355), - Trans(80, 84, 27, 355), - Trans(80, 87, 27, 355), - Trans(80, 89, 27, 355), - Trans(80, 91, 27, 355), - Trans(80, 106, 27, 355), - Trans(80, 114, 27, 355), - Trans(80, 115, 27, 355), - Trans(81, 5, 27, 355), - Trans(81, 16, 27, 355), - Trans(81, 17, 27, 355), - Trans(81, 18, 27, 355), - Trans(81, 19, 27, 355), - Trans(81, 20, 27, 355), - Trans(81, 21, 27, 355), - Trans(81, 22, 27, 355), - Trans(81, 23, 27, 355), - Trans(81, 24, 27, 355), - Trans(81, 25, 27, 355), - Trans(81, 26, 27, 355), - Trans(81, 31, 27, 355), - Trans(81, 32, 27, 355), - Trans(81, 33, 27, 355), - Trans(81, 34, 27, 355), - Trans(81, 43, 27, 355), - Trans(81, 44, 27, 355), - Trans(81, 45, 27, 355), - Trans(81, 46, 27, 355), - Trans(81, 48, 27, 355), - Trans(81, 52, 27, 355), - Trans(81, 94, 27, 355), - Trans(82, 5, 27, 355), - Trans(82, 6, 27, 355), - Trans(82, 7, 27, 355), - Trans(82, 8, 27, 355), - Trans(82, 9, 27, 355), - Trans(82, 10, 27, 355), - Trans(82, 11, 27, 355), - Trans(82, 18, 27, 355), - Trans(82, 24, 27, 355), - Trans(82, 25, 27, 355), - Trans(82, 26, 27, 355), - Trans(82, 27, 27, 355), - Trans(82, 37, 27, 355), - Trans(82, 39, 27, 355), - Trans(82, 40, 27, 355), - Trans(82, 42, 27, 355), - Trans(82, 54, 27, 355), - Trans(82, 71, 27, 355), - Trans(82, 77, 27, 355), - Trans(82, 82, 27, 355), - Trans(82, 84, 27, 355), - Trans(82, 87, 27, 355), - Trans(82, 89, 27, 355), - Trans(82, 91, 27, 355), - Trans(82, 106, 27, 355), - Trans(82, 114, 27, 355), - Trans(82, 115, 27, 355), - Trans(83, 5, 27, 355), - Trans(83, 12, 27, 355), - Trans(83, 14, 27, 355), - Trans(83, 16, 27, 355), - Trans(83, 17, 27, 355), - Trans(83, 18, 27, 355), - Trans(83, 19, 27, 355), - Trans(83, 20, 27, 355), - Trans(83, 21, 27, 355), - Trans(83, 22, 27, 355), - Trans(83, 23, 27, 355), - Trans(83, 24, 27, 355), - Trans(83, 25, 27, 355), - Trans(83, 26, 27, 355), - Trans(83, 31, 27, 355), - Trans(83, 32, 27, 355), - Trans(83, 33, 27, 355), - Trans(83, 34, 27, 355), - Trans(83, 37, 27, 355), - Trans(83, 40, 27, 355), - Trans(83, 43, 27, 355), - Trans(83, 44, 27, 355), - Trans(83, 45, 27, 355), - Trans(83, 46, 27, 355), - Trans(83, 47, 27, 355), - Trans(83, 48, 27, 355), - Trans(83, 49, 27, 355), - Trans(83, 50, 27, 355), - Trans(83, 51, 27, 355), - Trans(83, 52, 27, 355), - Trans(83, 61, 27, 355), - Trans(83, 62, 27, 355), - Trans(83, 65, 27, 355), - Trans(83, 66, 27, 355), - Trans(83, 67, 27, 355), - Trans(83, 71, 27, 355), - Trans(83, 72, 27, 355), - Trans(83, 74, 27, 355), - Trans(83, 78, 27, 355), - Trans(83, 81, 27, 355), - Trans(83, 82, 27, 355), - Trans(83, 85, 27, 355), - Trans(83, 94, 27, 355), - Trans(83, 103, 27, 355), - Trans(83, 105, 27, 355), - Trans(83, 108, 27, 355), - Trans(83, 111, 27, 355), - Trans(83, 112, 27, 355), - Trans(83, 113, 27, 355), - Trans(84, 5, 27, 355), - Trans(84, 16, 27, 355), - Trans(84, 17, 27, 355), - Trans(84, 18, 27, 355), - Trans(84, 19, 27, 355), - Trans(84, 20, 27, 355), - Trans(84, 21, 27, 355), - Trans(84, 22, 27, 355), - Trans(84, 23, 27, 355), - Trans(84, 24, 27, 355), - Trans(84, 25, 27, 355), - Trans(84, 26, 27, 355), - Trans(84, 30, 27, 355), - Trans(84, 31, 27, 355), - Trans(84, 32, 27, 355), - Trans(84, 33, 27, 355), - Trans(84, 34, 27, 355), - Trans(84, 35, 27, 355), - Trans(84, 41, 27, 355), - Trans(84, 42, 27, 355), - Trans(84, 43, 27, 355), - Trans(84, 44, 27, 355), - Trans(84, 45, 27, 355), - Trans(84, 46, 27, 355), - Trans(84, 48, 27, 355), - Trans(84, 52, 27, 355), - Trans(84, 94, 27, 355), - Trans(85, 5, 27, 355), - Trans(85, 16, 27, 355), - Trans(85, 17, 27, 355), - Trans(85, 18, 27, 355), - Trans(85, 19, 27, 355), - Trans(85, 20, 27, 355), - Trans(85, 21, 27, 355), - Trans(85, 22, 27, 355), - Trans(85, 23, 27, 355), - Trans(85, 24, 27, 355), - Trans(85, 25, 27, 355), - Trans(85, 26, 27, 355), - Trans(85, 29, 27, 355), - Trans(85, 30, 27, 355), - Trans(85, 31, 27, 355), - Trans(85, 32, 27, 355), - Trans(85, 33, 27, 355), - Trans(85, 34, 27, 355), - Trans(85, 35, 27, 355), - Trans(85, 36, 27, 355), - Trans(85, 41, 27, 355), - Trans(85, 42, 27, 355), - Trans(85, 43, 27, 355), - Trans(85, 44, 27, 355), - Trans(85, 45, 27, 355), - Trans(85, 46, 27, 355), - Trans(85, 48, 27, 355), - Trans(85, 52, 27, 355), - Trans(85, 94, 27, 355), - Trans(86, 5, 27, 355), - Trans(86, 16, 27, 355), - Trans(86, 17, 27, 355), - Trans(86, 18, 27, 355), - Trans(86, 19, 27, 355), - Trans(86, 20, 27, 355), - Trans(86, 21, 27, 355), - Trans(86, 22, 27, 355), - Trans(86, 23, 27, 355), - Trans(86, 24, 27, 355), - Trans(86, 25, 27, 355), - Trans(86, 26, 27, 355), - Trans(86, 31, 27, 355), - Trans(86, 32, 27, 355), - Trans(86, 40, 27, 355), - Trans(86, 44, 27, 355), - Trans(86, 48, 27, 355), - Trans(86, 52, 27, 355), - Trans(86, 103, 27, 355), - Trans(87, 5, 27, 355), - Trans(87, 16, 27, 355), - Trans(87, 17, 27, 355), - Trans(87, 18, 27, 355), - Trans(87, 19, 27, 355), - Trans(87, 20, 27, 355), - Trans(87, 21, 27, 355), - Trans(87, 22, 27, 355), - Trans(87, 23, 27, 355), - Trans(87, 24, 27, 355), - Trans(87, 25, 27, 355), - Trans(87, 26, 27, 355), - Trans(87, 30, 27, 355), - Trans(87, 31, 27, 355), - Trans(87, 32, 27, 355), - Trans(87, 35, 27, 355), - Trans(87, 40, 27, 355), - Trans(87, 41, 27, 355), - Trans(87, 42, 27, 355), - Trans(87, 44, 27, 355), - Trans(87, 48, 27, 355), - Trans(87, 52, 27, 355), - Trans(87, 103, 27, 355), - Trans(88, 5, 27, 355), - Trans(88, 16, 27, 355), - Trans(88, 17, 27, 355), - Trans(88, 18, 27, 355), - Trans(88, 19, 27, 355), - Trans(88, 20, 27, 355), - Trans(88, 21, 27, 355), - Trans(88, 22, 27, 355), - Trans(88, 23, 27, 355), - Trans(88, 24, 27, 355), - Trans(88, 25, 27, 355), - Trans(88, 26, 27, 355), - Trans(88, 29, 27, 355), - Trans(88, 30, 27, 355), - Trans(88, 31, 27, 355), - Trans(88, 32, 27, 355), - Trans(88, 35, 27, 355), - Trans(88, 40, 27, 355), - Trans(88, 41, 27, 355), - Trans(88, 42, 27, 355), - Trans(88, 44, 27, 355), - Trans(88, 48, 27, 355), - Trans(88, 52, 27, 355), - Trans(88, 103, 27, 355), - Trans(89, 5, 27, 355), - Trans(89, 16, 27, 355), - Trans(89, 17, 27, 355), - Trans(89, 18, 27, 355), - Trans(89, 19, 27, 355), - Trans(89, 20, 27, 355), - Trans(89, 21, 27, 355), - Trans(89, 22, 27, 355), - Trans(89, 23, 27, 355), - Trans(89, 24, 27, 355), - Trans(89, 25, 27, 355), - Trans(89, 26, 27, 355), - Trans(89, 32, 27, 355), - Trans(89, 44, 27, 355), - Trans(89, 46, 27, 355), - Trans(89, 47, 27, 355), - Trans(89, 48, 27, 355), - Trans(89, 52, 27, 355), - Trans(90, 5, 27, 355), - Trans(90, 16, 27, 355), - Trans(90, 17, 27, 355), - Trans(90, 18, 27, 355), - Trans(90, 19, 27, 355), - Trans(90, 20, 27, 355), - Trans(90, 21, 27, 355), - Trans(90, 22, 27, 355), - Trans(90, 23, 27, 355), - Trans(90, 24, 27, 355), - Trans(90, 25, 27, 355), - Trans(90, 26, 27, 355), - Trans(90, 30, 27, 355), - Trans(90, 32, 27, 355), - Trans(90, 35, 27, 355), - Trans(90, 41, 27, 355), - Trans(90, 42, 27, 355), - Trans(90, 44, 27, 355), - Trans(90, 46, 27, 355), - Trans(90, 47, 27, 355), - Trans(90, 48, 27, 355), - Trans(90, 52, 27, 355), - Trans(91, 5, 27, 355), - Trans(91, 16, 27, 355), - Trans(91, 17, 27, 355), - Trans(91, 18, 27, 355), - Trans(91, 19, 27, 355), - Trans(91, 20, 27, 355), - Trans(91, 21, 27, 355), - Trans(91, 22, 27, 355), - Trans(91, 23, 27, 355), - Trans(91, 24, 27, 355), - Trans(91, 25, 27, 355), - Trans(91, 26, 27, 355), - Trans(91, 29, 27, 355), - Trans(91, 30, 27, 355), - Trans(91, 32, 27, 355), - Trans(91, 35, 27, 355), - Trans(91, 41, 27, 355), - Trans(91, 42, 27, 355), - Trans(91, 44, 27, 355), - Trans(91, 46, 27, 355), - Trans(91, 47, 27, 355), - Trans(91, 48, 27, 355), - Trans(91, 52, 27, 355), - Trans(92, 5, 27, 355), - Trans(92, 16, 27, 355), - Trans(92, 17, 27, 355), - Trans(92, 18, 27, 355), - Trans(92, 19, 27, 355), - Trans(92, 20, 27, 355), - Trans(92, 21, 27, 355), - Trans(92, 22, 27, 355), - Trans(92, 23, 27, 355), - Trans(92, 24, 27, 355), - Trans(92, 25, 27, 355), - Trans(92, 26, 27, 355), - Trans(92, 32, 27, 355), - Trans(92, 43, 27, 355), - Trans(92, 48, 27, 355), - Trans(92, 52, 27, 355), - Trans(93, 5, 27, 355), - Trans(93, 16, 27, 355), - Trans(93, 17, 27, 355), - Trans(93, 18, 27, 355), - Trans(93, 19, 27, 355), - Trans(93, 20, 27, 355), - Trans(93, 21, 27, 355), - Trans(93, 22, 27, 355), - Trans(93, 23, 27, 355), - Trans(93, 24, 27, 355), - Trans(93, 25, 27, 355), - Trans(93, 26, 27, 355), - Trans(93, 30, 27, 355), - Trans(93, 32, 27, 355), - Trans(93, 35, 27, 355), - Trans(93, 41, 27, 355), - Trans(93, 42, 27, 355), - Trans(93, 43, 27, 355), - Trans(93, 48, 27, 355), - Trans(93, 52, 27, 355), - Trans(94, 5, 27, 355), - Trans(94, 16, 27, 355), - Trans(94, 17, 27, 355), - Trans(94, 18, 27, 355), - Trans(94, 19, 27, 355), - Trans(94, 20, 27, 355), - Trans(94, 21, 27, 355), - Trans(94, 22, 27, 355), - Trans(94, 23, 27, 355), - Trans(94, 24, 27, 355), - Trans(94, 25, 27, 355), - Trans(94, 26, 27, 355), - Trans(94, 29, 27, 355), - Trans(94, 30, 27, 355), - Trans(94, 32, 27, 355), - Trans(94, 35, 27, 355), - Trans(94, 41, 27, 355), - Trans(94, 42, 27, 355), - Trans(94, 43, 27, 355), - Trans(94, 48, 27, 355), - Trans(94, 52, 27, 355), - Trans(95, 6, 27, 355), - Trans(95, 7, 27, 355), - Trans(95, 8, 27, 355), - Trans(95, 9, 27, 355), - Trans(95, 10, 27, 355), - Trans(95, 11, 27, 355), - Trans(95, 18, 27, 355), - Trans(95, 24, 27, 355), - Trans(95, 25, 27, 355), - Trans(95, 26, 27, 355), - Trans(95, 27, 27, 355), - Trans(95, 31, 27, 355), - Trans(95, 37, 27, 355), - Trans(95, 39, 27, 355), - Trans(95, 40, 27, 355), - Trans(95, 42, 27, 355), - Trans(95, 44, 27, 355), - Trans(95, 49, 27, 355), - Trans(95, 50, 27, 355), - Trans(95, 51, 27, 355), - Trans(95, 54, 27, 355), - Trans(95, 58, 27, 355), - Trans(95, 61, 27, 355), - Trans(95, 65, 27, 355), - Trans(95, 66, 27, 355), - Trans(95, 67, 27, 355), - Trans(95, 70, 27, 355), - Trans(95, 71, 27, 355), - Trans(95, 72, 27, 355), - Trans(95, 74, 27, 355), - Trans(95, 77, 27, 355), - Trans(95, 78, 27, 355), - Trans(95, 81, 27, 355), - Trans(95, 82, 27, 355), - Trans(95, 84, 27, 355), - Trans(95, 85, 27, 355), - Trans(95, 87, 27, 355), - Trans(95, 89, 27, 355), - Trans(95, 100, 27, 355), - Trans(95, 101, 27, 355), - Trans(95, 105, 27, 355), - Trans(95, 106, 27, 355), - Trans(95, 108, 27, 355), - Trans(95, 111, 27, 355), - Trans(95, 112, 27, 355), - Trans(95, 113, 27, 355), - Trans(95, 114, 27, 355), - Trans(95, 115, 27, 355), - Trans(96, 5, 27, 355), - Trans(96, 16, 27, 355), - Trans(96, 17, 27, 355), - Trans(96, 18, 27, 355), - Trans(96, 19, 27, 355), - Trans(96, 20, 27, 355), - Trans(96, 21, 27, 355), - Trans(96, 22, 27, 355), - Trans(96, 23, 27, 355), - Trans(96, 24, 27, 355), - Trans(96, 25, 27, 355), - Trans(96, 26, 27, 355), - Trans(96, 31, 27, 355), - Trans(96, 32, 27, 355), - Trans(96, 33, 27, 355), - Trans(96, 34, 27, 355), - Trans(96, 44, 27, 355), - Trans(96, 48, 27, 355), - Trans(96, 52, 27, 355), - Trans(97, 5, 27, 355), - Trans(97, 6, 27, 355), - Trans(97, 7, 27, 355), - Trans(97, 8, 27, 355), - Trans(97, 9, 27, 355), - Trans(97, 10, 27, 355), - Trans(97, 11, 27, 355), - Trans(97, 18, 27, 355), - Trans(97, 24, 27, 355), - Trans(97, 25, 27, 355), - Trans(97, 26, 27, 355), - Trans(97, 27, 27, 355), - Trans(97, 31, 27, 355), - Trans(97, 37, 27, 355), - Trans(97, 39, 27, 355), - Trans(97, 40, 27, 355), - Trans(97, 42, 27, 355), - Trans(97, 44, 27, 355), - Trans(97, 49, 27, 355), - Trans(97, 50, 27, 355), - Trans(97, 51, 27, 355), - Trans(97, 54, 27, 355), - Trans(97, 61, 27, 355), - Trans(97, 65, 27, 355), - Trans(97, 66, 27, 355), - Trans(97, 67, 27, 355), - Trans(97, 71, 27, 355), - Trans(97, 72, 27, 355), - Trans(97, 74, 27, 355), - Trans(97, 77, 27, 355), - Trans(97, 78, 27, 355), - Trans(97, 81, 27, 355), - Trans(97, 82, 27, 355), - Trans(97, 84, 27, 355), - Trans(97, 85, 27, 355), - Trans(97, 87, 27, 355), - Trans(97, 89, 27, 355), - Trans(97, 105, 27, 355), - Trans(97, 106, 27, 355), - Trans(97, 108, 27, 355), - Trans(97, 111, 27, 355), - Trans(97, 112, 27, 355), - Trans(97, 113, 27, 355), - Trans(97, 114, 27, 355), - Trans(97, 115, 27, 355), - Trans(98, 5, 27, 355), - Trans(98, 6, 27, 355), - Trans(98, 7, 27, 355), - Trans(98, 8, 27, 355), - Trans(98, 9, 27, 355), - Trans(98, 10, 27, 355), - Trans(98, 11, 27, 355), - Trans(98, 18, 27, 355), - Trans(98, 24, 27, 355), - Trans(98, 25, 27, 355), - Trans(98, 26, 27, 355), - Trans(98, 27, 27, 355), - Trans(98, 31, 27, 355), - Trans(98, 37, 27, 355), - Trans(98, 39, 27, 355), - Trans(98, 40, 27, 355), - Trans(98, 42, 27, 355), - Trans(98, 44, 27, 355), - Trans(98, 49, 27, 355), - Trans(98, 50, 27, 355), - Trans(98, 51, 27, 355), - Trans(98, 54, 27, 355), - Trans(98, 58, 27, 355), - Trans(98, 59, 27, 355), - Trans(98, 61, 27, 355), - Trans(98, 62, 27, 355), - Trans(98, 65, 27, 355), - Trans(98, 66, 27, 355), - Trans(98, 67, 27, 355), - Trans(98, 70, 27, 355), - Trans(98, 71, 27, 355), - Trans(98, 72, 27, 355), - Trans(98, 74, 27, 355), - Trans(98, 77, 27, 355), - Trans(98, 78, 27, 355), - Trans(98, 81, 27, 355), - Trans(98, 82, 27, 355), - Trans(98, 84, 27, 355), - Trans(98, 85, 27, 355), - Trans(98, 87, 27, 355), - Trans(98, 89, 27, 355), - Trans(98, 100, 27, 355), - Trans(98, 101, 27, 355), - Trans(98, 105, 27, 355), - Trans(98, 106, 27, 355), - Trans(98, 108, 27, 355), - Trans(98, 111, 27, 355), - Trans(98, 112, 27, 355), - Trans(98, 113, 27, 355), - Trans(98, 114, 27, 355), - Trans(98, 115, 27, 355), - Trans(99, 5, 27, 355), - Trans(99, 15, 27, 355), - Trans(99, 16, 27, 355), - Trans(99, 17, 27, 355), - Trans(99, 18, 27, 355), - Trans(99, 19, 27, 355), - Trans(99, 20, 27, 355), - Trans(99, 21, 27, 355), - Trans(99, 22, 27, 355), - Trans(99, 23, 27, 355), - Trans(99, 24, 27, 355), - Trans(99, 25, 27, 355), - Trans(99, 26, 27, 355), - Trans(99, 30, 27, 355), - Trans(99, 31, 27, 355), - Trans(99, 32, 27, 355), - Trans(99, 33, 27, 355), - Trans(99, 34, 27, 355), - Trans(99, 35, 27, 355), - Trans(99, 36, 27, 355), - Trans(99, 41, 27, 355), - Trans(99, 42, 27, 355), - Trans(99, 44, 27, 355), - Trans(99, 48, 27, 355), - Trans(99, 52, 27, 355), - Trans(100, 5, 27, 355), - Trans(100, 15, 27, 355), - Trans(100, 16, 27, 355), - Trans(100, 17, 27, 355), - Trans(100, 18, 27, 355), - Trans(100, 19, 27, 355), - Trans(100, 20, 27, 355), - Trans(100, 21, 27, 355), - Trans(100, 22, 27, 355), - Trans(100, 23, 27, 355), - Trans(100, 24, 27, 355), - Trans(100, 25, 27, 355), - Trans(100, 26, 27, 355), - Trans(100, 29, 27, 355), - Trans(100, 30, 27, 355), - Trans(100, 31, 27, 355), - Trans(100, 32, 27, 355), - Trans(100, 33, 27, 355), - Trans(100, 34, 27, 355), - Trans(100, 35, 27, 355), - Trans(100, 36, 27, 355), - Trans(100, 41, 27, 355), - Trans(100, 42, 27, 355), - Trans(100, 44, 27, 355), - Trans(100, 48, 27, 355), - Trans(100, 52, 27, 355), - Trans(101, 5, 27, 355), - Trans(101, 12, 27, 355), - Trans(101, 14, 27, 355), - Trans(101, 16, 27, 355), - Trans(101, 17, 27, 355), - Trans(101, 18, 27, 355), - Trans(101, 19, 27, 355), - Trans(101, 20, 27, 355), - Trans(101, 21, 27, 355), - Trans(101, 22, 27, 355), - Trans(101, 23, 27, 355), - Trans(101, 24, 27, 355), - Trans(101, 25, 27, 355), - Trans(101, 26, 27, 355), - Trans(101, 31, 27, 355), - Trans(101, 32, 27, 355), - Trans(101, 45, 27, 355), - Trans(101, 48, 27, 355), - Trans(101, 52, 27, 355), - Trans(101, 103, 27, 355), - Trans(102, 5, 27, 355), - Trans(102, 12, 27, 355), - Trans(102, 14, 27, 355), - Trans(102, 16, 27, 355), - Trans(102, 17, 27, 355), - Trans(102, 18, 27, 355), - Trans(102, 19, 27, 355), - Trans(102, 20, 27, 355), - Trans(102, 21, 27, 355), - Trans(102, 22, 27, 355), - Trans(102, 23, 27, 355), - Trans(102, 24, 27, 355), - Trans(102, 25, 27, 355), - Trans(102, 26, 27, 355), - Trans(102, 30, 27, 355), - Trans(102, 31, 27, 355), - Trans(102, 32, 27, 355), - Trans(102, 35, 27, 355), - Trans(102, 41, 27, 355), - Trans(102, 42, 27, 355), - Trans(102, 45, 27, 355), - Trans(102, 48, 27, 355), - Trans(102, 52, 27, 355), - Trans(102, 103, 27, 355), - Trans(103, 5, 27, 355), - Trans(103, 12, 27, 355), - Trans(103, 14, 27, 355), - Trans(103, 16, 27, 355), - Trans(103, 17, 27, 355), - Trans(103, 18, 27, 355), - Trans(103, 19, 27, 355), - Trans(103, 20, 27, 355), - Trans(103, 21, 27, 355), - Trans(103, 22, 27, 355), - Trans(103, 23, 27, 355), - Trans(103, 24, 27, 355), - Trans(103, 25, 27, 355), - Trans(103, 26, 27, 355), - Trans(103, 29, 27, 355), - Trans(103, 30, 27, 355), - Trans(103, 31, 27, 355), - Trans(103, 32, 27, 355), - Trans(103, 35, 27, 355), - Trans(103, 41, 27, 355), - Trans(103, 42, 27, 355), - Trans(103, 45, 27, 355), - Trans(103, 48, 27, 355), - Trans(103, 52, 27, 355), - Trans(103, 103, 27, 355), - Trans(104, 6, 27, 355), - Trans(104, 7, 27, 355), - Trans(104, 8, 27, 355), - Trans(104, 9, 27, 355), - Trans(104, 10, 27, 355), - Trans(104, 11, 27, 355), - Trans(104, 18, 27, 355), - Trans(104, 24, 27, 355), - Trans(104, 25, 27, 355), - Trans(104, 26, 27, 355), - Trans(104, 27, 27, 355), - Trans(104, 37, 27, 355), - Trans(104, 39, 27, 355), - Trans(104, 40, 27, 355), - Trans(104, 42, 27, 355), - Trans(104, 46, 27, 355), - Trans(104, 54, 27, 355), - Trans(104, 71, 27, 355), - Trans(104, 77, 27, 355), - Trans(104, 84, 27, 355), - Trans(104, 87, 27, 355), - Trans(104, 89, 27, 355), - Trans(104, 106, 27, 355), - Trans(104, 114, 27, 355), - Trans(104, 115, 27, 355), - Trans(105, 5, 27, 355), - Trans(105, 16, 27, 355), - Trans(105, 17, 27, 355), - Trans(105, 18, 27, 355), - Trans(105, 19, 27, 355), - Trans(105, 20, 27, 355), - Trans(105, 21, 27, 355), - Trans(105, 22, 27, 355), - Trans(105, 23, 27, 355), - Trans(105, 24, 27, 355), - Trans(105, 25, 27, 355), - Trans(105, 26, 27, 355), - Trans(105, 32, 27, 355), - Trans(105, 46, 27, 355), - Trans(105, 48, 27, 355), - Trans(105, 52, 27, 355), - Trans(106, 5, 27, 355), - Trans(106, 6, 27, 355), - Trans(106, 7, 27, 355), - Trans(106, 8, 27, 355), - Trans(106, 9, 27, 355), - Trans(106, 10, 27, 355), - Trans(106, 11, 27, 355), - Trans(106, 18, 27, 355), - Trans(106, 24, 27, 355), - Trans(106, 25, 27, 355), - Trans(106, 26, 27, 355), - Trans(106, 27, 27, 355), - Trans(106, 37, 27, 355), - Trans(106, 39, 27, 355), - Trans(106, 40, 27, 355), - Trans(106, 42, 27, 355), - Trans(106, 54, 27, 355), - Trans(106, 71, 27, 355), - Trans(106, 77, 27, 355), - Trans(106, 84, 27, 355), - Trans(106, 87, 27, 355), - Trans(106, 89, 27, 355), - Trans(106, 106, 27, 355), - Trans(106, 114, 27, 355), - Trans(106, 115, 27, 355), - Trans(107, 5, 27, 355), - Trans(107, 16, 27, 355), - Trans(107, 17, 27, 355), - Trans(107, 18, 27, 355), - Trans(107, 19, 27, 355), - Trans(107, 20, 27, 355), - Trans(107, 21, 27, 355), - Trans(107, 22, 27, 355), - Trans(107, 23, 27, 355), - Trans(107, 24, 27, 355), - Trans(107, 25, 27, 355), - Trans(107, 26, 27, 355), - Trans(107, 30, 27, 355), - Trans(107, 32, 27, 355), - Trans(107, 35, 27, 355), - Trans(107, 41, 27, 355), - Trans(107, 42, 27, 355), - Trans(107, 46, 27, 355), - Trans(107, 48, 27, 355), - Trans(107, 52, 27, 355), - Trans(108, 5, 27, 355), - Trans(108, 16, 27, 355), - Trans(108, 17, 27, 355), - Trans(108, 18, 27, 355), - Trans(108, 19, 27, 355), - Trans(108, 20, 27, 355), - Trans(108, 21, 27, 355), - Trans(108, 22, 27, 355), - Trans(108, 23, 27, 355), - Trans(108, 24, 27, 355), - Trans(108, 25, 27, 355), - Trans(108, 26, 27, 355), - Trans(108, 29, 27, 355), - Trans(108, 30, 27, 355), - Trans(108, 31, 27, 355), - Trans(108, 32, 27, 355), - Trans(108, 35, 27, 355), - Trans(108, 41, 27, 355), - Trans(108, 42, 27, 355), - Trans(108, 46, 27, 355), - Trans(108, 48, 27, 355), - Trans(108, 52, 27, 355), - Trans(109, 5, 27, 355), - Trans(109, 16, 27, 355), - Trans(109, 17, 27, 355), - Trans(109, 18, 27, 355), - Trans(109, 19, 27, 355), - Trans(109, 20, 27, 355), - Trans(109, 21, 27, 355), - Trans(109, 22, 27, 355), - Trans(109, 23, 27, 355), - Trans(109, 24, 27, 355), - Trans(109, 25, 27, 355), - Trans(109, 26, 27, 355), - Trans(109, 33, 27, 355), - Trans(109, 34, 27, 355), - Trans(109, 40, 27, 355), - Trans(109, 48, 27, 355), - Trans(109, 52, 27, 355), - Trans(109, 103, 27, 355), - Trans(110, 5, 27, 355), - Trans(110, 16, 27, 355), - Trans(110, 17, 27, 355), - Trans(110, 18, 27, 355), - Trans(110, 19, 27, 355), - Trans(110, 20, 27, 355), - Trans(110, 21, 27, 355), - Trans(110, 22, 27, 355), - Trans(110, 23, 27, 355), - Trans(110, 24, 27, 355), - Trans(110, 25, 27, 355), - Trans(110, 26, 27, 355), - Trans(110, 30, 27, 355), - Trans(110, 33, 27, 355), - Trans(110, 34, 27, 355), - Trans(110, 35, 27, 355), - Trans(110, 40, 27, 355), - Trans(110, 41, 27, 355), - Trans(110, 42, 27, 355), - Trans(110, 48, 27, 355), - Trans(110, 52, 27, 355), - Trans(110, 103, 27, 355), - Trans(111, 5, 27, 355), - Trans(111, 16, 27, 355), - Trans(111, 17, 27, 355), - Trans(111, 18, 27, 355), - Trans(111, 19, 27, 355), - Trans(111, 20, 27, 355), - Trans(111, 21, 27, 355), - Trans(111, 22, 27, 355), - Trans(111, 23, 27, 355), - Trans(111, 24, 27, 355), - Trans(111, 25, 27, 355), - Trans(111, 26, 27, 355), - Trans(111, 29, 27, 355), - Trans(111, 30, 27, 355), - Trans(111, 33, 27, 355), - Trans(111, 34, 27, 355), - Trans(111, 35, 27, 355), - Trans(111, 40, 27, 355), - Trans(111, 41, 27, 355), - Trans(111, 42, 27, 355), - Trans(111, 48, 27, 355), - Trans(111, 52, 27, 355), - Trans(111, 103, 27, 355), - Trans(112, 5, 27, 355), - Trans(112, 16, 27, 355), - Trans(112, 17, 27, 355), - Trans(112, 18, 27, 355), - Trans(112, 19, 27, 355), - Trans(112, 20, 27, 355), - Trans(112, 21, 27, 355), - Trans(112, 22, 27, 355), - Trans(112, 23, 27, 355), - Trans(112, 24, 27, 355), - Trans(112, 25, 27, 355), - Trans(112, 26, 27, 355), - Trans(112, 32, 27, 355), - Trans(112, 44, 27, 355), - Trans(112, 48, 27, 355), - Trans(112, 52, 27, 355), - Trans(113, 5, 27, 355), - Trans(113, 16, 27, 355), - Trans(113, 17, 27, 355), - Trans(113, 18, 27, 355), - Trans(113, 19, 27, 355), - Trans(113, 20, 27, 355), - Trans(113, 21, 27, 355), - Trans(113, 22, 27, 355), - Trans(113, 23, 27, 355), - Trans(113, 24, 27, 355), - Trans(113, 25, 27, 355), - Trans(113, 26, 27, 355), - Trans(113, 30, 27, 355), - Trans(113, 32, 27, 355), - Trans(113, 35, 27, 355), - Trans(113, 41, 27, 355), - Trans(113, 42, 27, 355), - Trans(113, 44, 27, 355), - Trans(113, 48, 27, 355), - Trans(113, 52, 27, 355), - Trans(114, 5, 27, 355), - Trans(114, 16, 27, 355), - Trans(114, 17, 27, 355), - Trans(114, 18, 27, 355), - Trans(114, 19, 27, 355), - Trans(114, 20, 27, 355), - Trans(114, 21, 27, 355), - Trans(114, 22, 27, 355), - Trans(114, 23, 27, 355), - Trans(114, 24, 27, 355), - Trans(114, 25, 27, 355), - Trans(114, 26, 27, 355), - Trans(114, 29, 27, 355), - Trans(114, 30, 27, 355), - Trans(114, 32, 27, 355), - Trans(114, 35, 27, 355), - Trans(114, 41, 27, 355), - Trans(114, 42, 27, 355), - Trans(114, 44, 27, 355), - Trans(114, 48, 27, 355), - Trans(114, 52, 27, 355), - Trans(115, 6, 27, 355), - Trans(115, 7, 27, 355), - Trans(115, 8, 27, 355), - Trans(115, 9, 27, 355), - Trans(115, 10, 27, 355), - Trans(115, 11, 27, 355), - Trans(115, 15, 27, 355), - Trans(115, 18, 27, 355), - Trans(115, 24, 27, 355), - Trans(115, 25, 27, 355), - Trans(115, 26, 27, 355), - Trans(115, 27, 27, 355), - Trans(115, 39, 27, 355), - Trans(115, 40, 27, 355), - Trans(115, 42, 27, 355), - Trans(115, 54, 27, 355), - Trans(115, 71, 27, 355), - Trans(115, 77, 27, 355), - Trans(115, 84, 27, 355), - Trans(115, 87, 27, 355), - Trans(115, 89, 27, 355), - Trans(115, 106, 27, 355), - Trans(115, 114, 27, 355), - Trans(115, 115, 27, 355), - Trans(116, 12, 27, 355), - Trans(116, 14, 27, 355), - Trans(116, 15, 27, 355), - Trans(116, 16, 27, 355), - Trans(116, 17, 27, 355), - Trans(116, 18, 27, 355), - Trans(116, 19, 27, 355), - Trans(116, 20, 27, 355), - Trans(116, 21, 27, 355), - Trans(116, 22, 27, 355), - Trans(116, 23, 27, 355), - Trans(116, 24, 27, 355), - Trans(116, 25, 27, 355), - Trans(116, 26, 27, 355), - Trans(116, 31, 27, 355), - Trans(116, 32, 27, 355), - Trans(116, 33, 27, 355), - Trans(116, 34, 27, 355), - Trans(116, 35, 27, 355), - Trans(116, 36, 27, 355), - Trans(116, 37, 27, 355), - Trans(116, 40, 27, 355), - Trans(116, 41, 27, 355), - Trans(116, 42, 27, 355), - Trans(116, 43, 27, 355), - Trans(116, 44, 27, 355), - Trans(116, 45, 27, 355), - Trans(116, 46, 27, 355), - Trans(116, 47, 27, 355), - Trans(116, 48, 27, 355), - Trans(116, 52, 27, 355), - Trans(116, 94, 27, 355), - Trans(116, 103, 27, 355), - Trans(117, 5, 27, 355), - Trans(117, 6, 27, 355), - Trans(117, 7, 27, 355), - Trans(117, 8, 27, 355), - Trans(117, 9, 27, 355), - Trans(117, 10, 27, 355), - Trans(117, 11, 27, 355), - Trans(117, 18, 27, 355), - Trans(117, 24, 27, 355), - Trans(117, 25, 27, 355), - Trans(117, 26, 27, 355), - Trans(117, 27, 27, 355), - Trans(117, 31, 27, 355), - Trans(117, 37, 27, 355), - Trans(117, 39, 27, 355), - Trans(117, 40, 27, 355), - Trans(117, 42, 27, 355), - Trans(117, 44, 27, 355), - Trans(117, 49, 27, 355), - Trans(117, 50, 27, 355), - Trans(117, 51, 27, 355), - Trans(117, 54, 27, 355), - Trans(117, 58, 27, 355), - Trans(117, 61, 27, 355), - Trans(117, 65, 27, 355), - Trans(117, 66, 27, 355), - Trans(117, 67, 27, 355), - Trans(117, 70, 27, 355), - Trans(117, 71, 27, 355), - Trans(117, 72, 27, 355), - Trans(117, 74, 27, 355), - Trans(117, 77, 27, 355), - Trans(117, 78, 27, 355), - Trans(117, 81, 27, 355), - Trans(117, 82, 27, 355), - Trans(117, 84, 27, 355), - Trans(117, 85, 27, 355), - Trans(117, 87, 27, 355), - Trans(117, 89, 27, 355), - Trans(117, 100, 27, 355), - Trans(117, 101, 27, 355), - Trans(117, 105, 27, 355), - Trans(117, 106, 27, 355), - Trans(117, 108, 27, 355), - Trans(117, 111, 27, 355), - Trans(117, 112, 27, 355), - Trans(117, 113, 27, 355), - Trans(117, 114, 27, 355), - Trans(117, 115, 27, 355), - Trans(118, 12, 27, 355), - Trans(118, 13, 27, 355), - Trans(118, 14, 27, 355), - Trans(118, 16, 27, 355), - Trans(118, 17, 27, 355), - Trans(118, 18, 27, 355), - Trans(118, 19, 27, 355), - Trans(118, 20, 27, 355), - Trans(118, 21, 27, 355), - Trans(118, 22, 27, 355), - Trans(118, 23, 27, 355), - Trans(118, 24, 27, 355), - Trans(118, 25, 27, 355), - Trans(118, 26, 27, 355), - Trans(118, 31, 27, 355), - Trans(118, 32, 27, 355), - Trans(118, 33, 27, 355), - Trans(118, 34, 27, 355), - Trans(118, 40, 27, 355), - Trans(118, 42, 27, 355), - Trans(118, 43, 27, 355), - Trans(118, 44, 27, 355), - Trans(118, 45, 27, 355), - Trans(118, 46, 27, 355), - Trans(118, 47, 27, 355), - Trans(118, 48, 27, 355), - Trans(118, 52, 27, 355), - Trans(118, 94, 27, 355), - Trans(118, 103, 27, 355), - Trans(119, 5, 27, 355), - Trans(119, 37, 27, 355), - Trans(119, 40, 27, 355), - Trans(119, 46, 27, 355), - Trans(119, 115, 27, 355), - Trans(120, 5, 27, 355), - Trans(120, 12, 27, 355), - Trans(120, 14, 27, 355), - Trans(120, 16, 27, 355), - Trans(120, 17, 27, 355), - Trans(120, 18, 27, 355), - Trans(120, 19, 27, 355), - Trans(120, 20, 27, 355), - Trans(120, 21, 27, 355), - Trans(120, 22, 27, 355), - Trans(120, 23, 27, 355), - Trans(120, 24, 27, 355), - Trans(120, 25, 27, 355), - Trans(120, 26, 27, 355), - Trans(120, 31, 27, 355), - Trans(120, 32, 27, 355), - Trans(120, 33, 27, 355), - Trans(120, 34, 27, 355), - Trans(120, 40, 27, 355), - Trans(120, 42, 27, 355), - Trans(120, 43, 27, 355), - Trans(120, 44, 27, 355), - Trans(120, 45, 27, 355), - Trans(120, 46, 27, 355), - Trans(120, 47, 27, 355), - Trans(120, 48, 27, 355), - Trans(120, 52, 27, 355), - Trans(120, 94, 27, 355), - Trans(120, 103, 27, 355), - Trans(121, 42, 27, 355), - Trans(122, 55, 27, 355), - Trans(122, 56, 27, 355), - Trans(122, 57, 27, 355), - Trans(122, 63, 27, 355), - Trans(122, 64, 27, 355), - Trans(122, 68, 27, 355), - Trans(122, 69, 27, 355), - Trans(122, 95, 27, 355), - Trans(122, 96, 27, 355), - Trans(122, 97, 27, 355), - Trans(122, 98, 27, 355), - Trans(122, 99, 27, 355), - Trans(122, 109, 27, 355), - Trans(122, 110, 27, 355), - Trans(122, 114, 27, 355), - Trans(122, 115, 27, 355), - Trans(123, 5, 27, 355), - Trans(123, 12, 27, 355), - Trans(123, 14, 27, 355), - Trans(123, 16, 27, 355), - Trans(123, 17, 27, 355), - Trans(123, 18, 27, 355), - Trans(123, 19, 27, 355), - Trans(123, 20, 27, 355), - Trans(123, 21, 27, 355), - Trans(123, 22, 27, 355), - Trans(123, 23, 27, 355), - Trans(123, 24, 27, 355), - Trans(123, 25, 27, 355), - Trans(123, 26, 27, 355), - Trans(123, 31, 27, 355), - Trans(123, 32, 27, 355), - Trans(123, 33, 27, 355), - Trans(123, 34, 27, 355), - Trans(123, 40, 27, 355), - Trans(123, 43, 27, 355), - Trans(123, 44, 27, 355), - Trans(123, 45, 27, 355), - Trans(123, 46, 27, 355), - Trans(123, 47, 27, 355), - Trans(123, 48, 27, 355), - Trans(123, 94, 27, 355), - Trans(123, 103, 27, 355), - Trans(124, 5, 27, 355), - Trans(124, 12, 27, 355), - Trans(124, 14, 27, 355), - Trans(124, 16, 27, 355), - Trans(124, 17, 27, 355), - Trans(124, 18, 27, 355), - Trans(124, 19, 27, 355), - Trans(124, 20, 27, 355), - Trans(124, 21, 27, 355), - Trans(124, 22, 27, 355), - Trans(124, 23, 27, 355), - Trans(124, 24, 27, 355), - Trans(124, 25, 27, 355), - Trans(124, 26, 27, 355), - Trans(124, 30, 27, 355), - Trans(124, 31, 27, 355), - Trans(124, 32, 27, 355), - Trans(124, 33, 27, 355), - Trans(124, 34, 27, 355), - Trans(124, 40, 27, 355), - Trans(124, 43, 27, 355), - Trans(124, 44, 27, 355), - Trans(124, 45, 27, 355), - Trans(124, 46, 27, 355), - Trans(124, 47, 27, 355), - Trans(124, 48, 27, 355), - Trans(124, 94, 27, 355), - Trans(124, 103, 27, 355), - Trans(125, 5, 27, 355), - Trans(125, 12, 27, 355), - Trans(125, 14, 27, 355), - Trans(125, 16, 27, 355), - Trans(125, 17, 27, 355), - Trans(125, 18, 27, 355), - Trans(125, 19, 27, 355), - Trans(125, 20, 27, 355), - Trans(125, 21, 27, 355), - Trans(125, 22, 27, 355), - Trans(125, 23, 27, 355), - Trans(125, 24, 27, 355), - Trans(125, 25, 27, 355), - Trans(125, 26, 27, 355), - Trans(125, 29, 27, 355), - Trans(125, 30, 27, 355), - Trans(125, 31, 27, 355), - Trans(125, 32, 27, 355), - Trans(125, 33, 27, 355), - Trans(125, 34, 27, 355), - Trans(125, 40, 27, 355), - Trans(125, 43, 27, 355), - Trans(125, 44, 27, 355), - Trans(125, 45, 27, 355), - Trans(125, 46, 27, 355), - Trans(125, 47, 27, 355), - Trans(125, 48, 27, 355), - Trans(125, 94, 27, 355), - Trans(125, 103, 27, 355), - Trans(126, 115, 27, 355), - Trans(127, 5, 27, 355), - Trans(127, 12, 27, 355), - Trans(127, 14, 27, 355), - Trans(127, 15, 27, 355), - Trans(127, 16, 27, 355), - Trans(127, 17, 27, 355), - Trans(127, 18, 27, 355), - Trans(127, 19, 27, 355), - Trans(127, 20, 27, 355), - Trans(127, 21, 27, 355), - Trans(127, 22, 27, 355), - Trans(127, 23, 27, 355), - Trans(127, 24, 27, 355), - Trans(127, 25, 27, 355), - Trans(127, 26, 27, 355), - Trans(127, 31, 27, 355), - Trans(127, 32, 27, 355), - Trans(127, 33, 27, 355), - Trans(127, 34, 27, 355), - Trans(127, 35, 27, 355), - Trans(127, 36, 27, 355), - Trans(127, 40, 27, 355), - Trans(127, 41, 27, 355), - Trans(127, 42, 27, 355), - Trans(127, 43, 27, 355), - Trans(127, 44, 27, 355), - Trans(127, 45, 27, 355), - Trans(127, 46, 27, 355), - Trans(127, 47, 27, 355), - Trans(127, 48, 27, 355), - Trans(127, 52, 27, 355), - Trans(127, 94, 27, 355), - Trans(127, 103, 27, 355), + Trans(26, 72, 30, -1), + Trans(26, 78, 30, -1), + Trans(26, 85, 76, -1), + Trans(26, 88, 76, -1), + Trans(26, 90, 30, -1), + Trans(26, 108, 36, -1), + Trans(26, 116, 77, -1), + Trans(26, 117, 78, -1), + Trans(28, 0, 27, 361), + Trans(28, 6, 27, 361), + Trans(28, 7, 27, 361), + Trans(28, 8, 27, 361), + Trans(28, 9, 27, 361), + Trans(28, 10, 27, 361), + Trans(28, 11, 27, 361), + Trans(28, 18, 27, 361), + Trans(28, 24, 27, 361), + Trans(28, 25, 27, 361), + Trans(28, 26, 27, 361), + Trans(28, 27, 27, 361), + Trans(28, 31, 27, 361), + Trans(28, 37, 27, 361), + Trans(28, 39, 27, 361), + Trans(28, 40, 27, 361), + Trans(28, 42, 27, 361), + Trans(28, 44, 27, 361), + Trans(28, 49, 27, 361), + Trans(28, 50, 27, 361), + Trans(28, 51, 27, 361), + Trans(28, 54, 27, 361), + Trans(28, 59, 27, 361), + Trans(28, 61, 27, 361), + Trans(28, 62, 27, 361), + Trans(28, 63, 27, 361), + Trans(28, 66, 27, 361), + Trans(28, 67, 27, 361), + Trans(28, 68, 27, 361), + Trans(28, 71, 27, 361), + Trans(28, 72, 27, 361), + Trans(28, 73, 27, 361), + Trans(28, 74, 27, 361), + Trans(28, 75, 27, 361), + Trans(28, 78, 27, 361), + Trans(28, 79, 27, 361), + Trans(28, 80, 27, 361), + Trans(28, 82, 27, 361), + Trans(28, 83, 27, 361), + Trans(28, 85, 27, 361), + Trans(28, 86, 27, 361), + Trans(28, 87, 27, 361), + Trans(28, 88, 27, 361), + Trans(28, 90, 27, 361), + Trans(28, 91, 27, 361), + Trans(28, 93, 27, 361), + Trans(28, 94, 27, 361), + Trans(28, 102, 27, 361), + Trans(28, 103, 27, 361), + Trans(28, 107, 27, 361), + Trans(28, 108, 27, 361), + Trans(28, 110, 27, 361), + Trans(28, 113, 27, 361), + Trans(28, 114, 27, 361), + Trans(28, 115, 27, 361), + Trans(28, 116, 27, 361), + Trans(28, 117, 27, 361), + Trans(29, 5, 27, 361), + Trans(29, 16, 27, 361), + Trans(29, 17, 27, 361), + Trans(29, 18, 27, 361), + Trans(29, 19, 27, 361), + Trans(29, 20, 27, 361), + Trans(29, 21, 27, 361), + Trans(29, 22, 27, 361), + Trans(29, 23, 27, 361), + Trans(29, 24, 27, 361), + Trans(29, 25, 27, 361), + Trans(29, 26, 27, 361), + Trans(29, 31, 27, 361), + Trans(29, 32, 27, 361), + Trans(29, 33, 27, 361), + Trans(29, 34, 27, 361), + Trans(29, 48, 27, 361), + Trans(29, 52, 27, 361), + Trans(30, 5, 27, 361), + Trans(30, 6, 27, 361), + Trans(30, 7, 27, 361), + Trans(30, 8, 27, 361), + Trans(30, 9, 27, 361), + Trans(30, 10, 27, 361), + Trans(30, 11, 27, 361), + Trans(30, 18, 27, 361), + Trans(30, 24, 27, 361), + Trans(30, 25, 27, 361), + Trans(30, 26, 27, 361), + Trans(30, 27, 27, 361), + Trans(30, 39, 27, 361), + Trans(30, 40, 27, 361), + Trans(30, 42, 27, 361), + Trans(30, 54, 27, 361), + Trans(30, 72, 27, 361), + Trans(30, 78, 27, 361), + Trans(30, 85, 27, 361), + Trans(30, 88, 27, 361), + Trans(30, 90, 27, 361), + Trans(30, 108, 27, 361), + Trans(30, 116, 27, 361), + Trans(30, 117, 27, 361), + Trans(31, 5, 27, 361), + Trans(31, 117, 27, 361), + Trans(32, 5, 27, 361), + Trans(32, 41, 27, 361), + Trans(33, 5, 27, 361), + Trans(33, 6, 27, 361), + Trans(33, 7, 27, 361), + Trans(33, 8, 27, 361), + Trans(33, 9, 27, 361), + Trans(33, 10, 27, 361), + Trans(33, 11, 27, 361), + Trans(33, 18, 27, 361), + Trans(33, 24, 27, 361), + Trans(33, 25, 27, 361), + Trans(33, 26, 27, 361), + Trans(33, 27, 27, 361), + Trans(33, 39, 27, 361), + Trans(33, 40, 27, 361), + Trans(33, 42, 27, 361), + Trans(33, 54, 27, 361), + Trans(33, 59, 27, 361), + Trans(33, 72, 27, 361), + Trans(33, 78, 27, 361), + Trans(33, 85, 27, 361), + Trans(33, 88, 27, 361), + Trans(33, 90, 27, 361), + Trans(33, 108, 27, 361), + Trans(33, 116, 27, 361), + Trans(33, 117, 27, 361), + Trans(34, 5, 27, 361), + Trans(34, 6, 27, 361), + Trans(34, 7, 27, 361), + Trans(34, 8, 27, 361), + Trans(34, 9, 27, 361), + Trans(34, 10, 27, 361), + Trans(34, 11, 27, 361), + Trans(34, 18, 27, 361), + Trans(34, 24, 27, 361), + Trans(34, 25, 27, 361), + Trans(34, 26, 27, 361), + Trans(34, 27, 27, 361), + Trans(34, 31, 27, 361), + Trans(34, 37, 27, 361), + Trans(34, 39, 27, 361), + Trans(34, 40, 27, 361), + Trans(34, 42, 27, 361), + Trans(34, 44, 27, 361), + Trans(34, 49, 27, 361), + Trans(34, 50, 27, 361), + Trans(34, 51, 27, 361), + Trans(34, 54, 27, 361), + Trans(34, 61, 27, 361), + Trans(34, 62, 27, 361), + Trans(34, 63, 27, 361), + Trans(34, 66, 27, 361), + Trans(34, 67, 27, 361), + Trans(34, 68, 27, 361), + Trans(34, 72, 27, 361), + Trans(34, 73, 27, 361), + Trans(34, 74, 27, 361), + Trans(34, 75, 27, 361), + Trans(34, 78, 27, 361), + Trans(34, 79, 27, 361), + Trans(34, 80, 27, 361), + Trans(34, 82, 27, 361), + Trans(34, 83, 27, 361), + Trans(34, 85, 27, 361), + Trans(34, 86, 27, 361), + Trans(34, 87, 27, 361), + Trans(34, 88, 27, 361), + Trans(34, 90, 27, 361), + Trans(34, 91, 27, 361), + Trans(34, 93, 27, 361), + Trans(34, 94, 27, 361), + Trans(34, 107, 27, 361), + Trans(34, 108, 27, 361), + Trans(34, 110, 27, 361), + Trans(34, 113, 27, 361), + Trans(34, 114, 27, 361), + Trans(34, 115, 27, 361), + Trans(34, 116, 27, 361), + Trans(34, 117, 27, 361), + Trans(35, 0, 27, 361), + Trans(35, 5, 27, 361), + Trans(35, 6, 27, 361), + Trans(35, 7, 27, 361), + Trans(35, 8, 27, 361), + Trans(35, 9, 27, 361), + Trans(35, 10, 27, 361), + Trans(35, 11, 27, 361), + Trans(35, 18, 27, 361), + Trans(35, 24, 27, 361), + Trans(35, 25, 27, 361), + Trans(35, 26, 27, 361), + Trans(35, 27, 27, 361), + Trans(35, 31, 27, 361), + Trans(35, 37, 27, 361), + Trans(35, 39, 27, 361), + Trans(35, 40, 27, 361), + Trans(35, 42, 27, 361), + Trans(35, 44, 27, 361), + Trans(35, 49, 27, 361), + Trans(35, 50, 27, 361), + Trans(35, 51, 27, 361), + Trans(35, 54, 27, 361), + Trans(35, 59, 27, 361), + Trans(35, 60, 27, 361), + Trans(35, 61, 27, 361), + Trans(35, 62, 27, 361), + Trans(35, 63, 27, 361), + Trans(35, 66, 27, 361), + Trans(35, 67, 27, 361), + Trans(35, 68, 27, 361), + Trans(35, 71, 27, 361), + Trans(35, 72, 27, 361), + Trans(35, 73, 27, 361), + Trans(35, 74, 27, 361), + Trans(35, 75, 27, 361), + Trans(35, 78, 27, 361), + Trans(35, 79, 27, 361), + Trans(35, 80, 27, 361), + Trans(35, 82, 27, 361), + Trans(35, 83, 27, 361), + Trans(35, 85, 27, 361), + Trans(35, 86, 27, 361), + Trans(35, 87, 27, 361), + Trans(35, 88, 27, 361), + Trans(35, 90, 27, 361), + Trans(35, 91, 27, 361), + Trans(35, 93, 27, 361), + Trans(35, 94, 27, 361), + Trans(35, 102, 27, 361), + Trans(35, 103, 27, 361), + Trans(35, 107, 27, 361), + Trans(35, 108, 27, 361), + Trans(35, 110, 27, 361), + Trans(35, 113, 27, 361), + Trans(35, 114, 27, 361), + Trans(35, 115, 27, 361), + Trans(35, 116, 27, 361), + Trans(35, 117, 27, 361), + Trans(36, 5, 27, 361), + Trans(36, 40, 27, 361), + Trans(37, 5, 27, 361), + Trans(37, 40, 27, 361), + Trans(37, 42, 27, 361), + Trans(38, 5, 27, 361), + Trans(38, 31, 27, 361), + Trans(39, 5, 27, 361), + Trans(39, 42, 27, 361), + Trans(40, 5, 27, 361), + Trans(40, 48, 27, 361), + Trans(40, 116, 27, 361), + Trans(40, 117, 27, 361), + Trans(41, 5, 27, 361), + Trans(41, 116, 27, 361), + Trans(41, 117, 27, 361), + Trans(42, 5, 27, 361), + Trans(42, 87, 27, 361), + Trans(43, 5, 27, 361), + Trans(43, 80, 27, 361), + Trans(43, 87, 27, 361), + Trans(43, 91, 27, 361), + Trans(43, 93, 27, 361), + Trans(44, 5, 27, 361), + Trans(44, 47, 27, 361), + Trans(45, 5, 27, 361), + Trans(45, 15, 27, 361), + Trans(45, 16, 27, 361), + Trans(45, 17, 27, 361), + Trans(45, 18, 27, 361), + Trans(45, 19, 27, 361), + Trans(45, 20, 27, 361), + Trans(45, 21, 27, 361), + Trans(45, 22, 27, 361), + Trans(45, 23, 27, 361), + Trans(45, 24, 27, 361), + Trans(45, 25, 27, 361), + Trans(45, 26, 27, 361), + Trans(45, 30, 27, 361), + Trans(45, 31, 27, 361), + Trans(45, 32, 27, 361), + Trans(45, 33, 27, 361), + Trans(45, 34, 27, 361), + Trans(45, 35, 27, 361), + Trans(45, 36, 27, 361), + Trans(45, 41, 27, 361), + Trans(45, 42, 27, 361), + Trans(45, 48, 27, 361), + Trans(45, 52, 27, 361), + Trans(46, 5, 27, 361), + Trans(46, 15, 27, 361), + Trans(46, 16, 27, 361), + Trans(46, 17, 27, 361), + Trans(46, 18, 27, 361), + Trans(46, 19, 27, 361), + Trans(46, 20, 27, 361), + Trans(46, 21, 27, 361), + Trans(46, 22, 27, 361), + Trans(46, 23, 27, 361), + Trans(46, 24, 27, 361), + Trans(46, 25, 27, 361), + Trans(46, 26, 27, 361), + Trans(46, 29, 27, 361), + Trans(46, 30, 27, 361), + Trans(46, 31, 27, 361), + Trans(46, 32, 27, 361), + Trans(46, 33, 27, 361), + Trans(46, 34, 27, 361), + Trans(46, 35, 27, 361), + Trans(46, 36, 27, 361), + Trans(46, 41, 27, 361), + Trans(46, 42, 27, 361), + Trans(46, 48, 27, 361), + Trans(46, 52, 27, 361), + Trans(47, 6, 27, 361), + Trans(47, 7, 27, 361), + Trans(47, 8, 27, 361), + Trans(47, 9, 27, 361), + Trans(47, 10, 27, 361), + Trans(47, 11, 27, 361), + Trans(47, 18, 27, 361), + Trans(47, 24, 27, 361), + Trans(47, 25, 27, 361), + Trans(47, 26, 27, 361), + Trans(47, 27, 27, 361), + Trans(47, 31, 27, 361), + Trans(47, 37, 27, 361), + Trans(47, 39, 27, 361), + Trans(47, 40, 27, 361), + Trans(47, 42, 27, 361), + Trans(47, 44, 27, 361), + Trans(47, 49, 27, 361), + Trans(47, 50, 27, 361), + Trans(47, 51, 27, 361), + Trans(47, 54, 27, 361), + Trans(47, 59, 27, 361), + Trans(47, 62, 27, 361), + Trans(47, 66, 27, 361), + Trans(47, 67, 27, 361), + Trans(47, 68, 27, 361), + Trans(47, 71, 27, 361), + Trans(47, 72, 27, 361), + Trans(47, 73, 27, 361), + Trans(47, 75, 27, 361), + Trans(47, 78, 27, 361), + Trans(47, 79, 27, 361), + Trans(47, 82, 27, 361), + Trans(47, 83, 27, 361), + Trans(47, 85, 27, 361), + Trans(47, 86, 27, 361), + Trans(47, 88, 27, 361), + Trans(47, 90, 27, 361), + Trans(47, 102, 27, 361), + Trans(47, 103, 27, 361), + Trans(47, 107, 27, 361), + Trans(47, 108, 27, 361), + Trans(47, 110, 27, 361), + Trans(47, 113, 27, 361), + Trans(47, 114, 27, 361), + Trans(47, 115, 27, 361), + Trans(47, 116, 27, 361), + Trans(47, 117, 27, 361), + Trans(48, 5, 27, 361), + Trans(48, 16, 27, 361), + Trans(48, 17, 27, 361), + Trans(48, 18, 27, 361), + Trans(48, 19, 27, 361), + Trans(48, 20, 27, 361), + Trans(48, 21, 27, 361), + Trans(48, 22, 27, 361), + Trans(48, 23, 27, 361), + Trans(48, 24, 27, 361), + Trans(48, 25, 27, 361), + Trans(48, 26, 27, 361), + Trans(48, 31, 27, 361), + Trans(48, 32, 27, 361), + Trans(48, 33, 27, 361), + Trans(48, 34, 27, 361), + Trans(48, 44, 27, 361), + Trans(48, 48, 27, 361), + Trans(48, 52, 27, 361), + Trans(49, 5, 27, 361), + Trans(49, 6, 27, 361), + Trans(49, 7, 27, 361), + Trans(49, 8, 27, 361), + Trans(49, 9, 27, 361), + Trans(49, 10, 27, 361), + Trans(49, 11, 27, 361), + Trans(49, 18, 27, 361), + Trans(49, 24, 27, 361), + Trans(49, 25, 27, 361), + Trans(49, 26, 27, 361), + Trans(49, 27, 27, 361), + Trans(49, 31, 27, 361), + Trans(49, 37, 27, 361), + Trans(49, 39, 27, 361), + Trans(49, 40, 27, 361), + Trans(49, 42, 27, 361), + Trans(49, 44, 27, 361), + Trans(49, 49, 27, 361), + Trans(49, 50, 27, 361), + Trans(49, 51, 27, 361), + Trans(49, 54, 27, 361), + Trans(49, 62, 27, 361), + Trans(49, 66, 27, 361), + Trans(49, 67, 27, 361), + Trans(49, 68, 27, 361), + Trans(49, 72, 27, 361), + Trans(49, 73, 27, 361), + Trans(49, 75, 27, 361), + Trans(49, 78, 27, 361), + Trans(49, 79, 27, 361), + Trans(49, 82, 27, 361), + Trans(49, 83, 27, 361), + Trans(49, 85, 27, 361), + Trans(49, 86, 27, 361), + Trans(49, 88, 27, 361), + Trans(49, 90, 27, 361), + Trans(49, 107, 27, 361), + Trans(49, 108, 27, 361), + Trans(49, 110, 27, 361), + Trans(49, 113, 27, 361), + Trans(49, 114, 27, 361), + Trans(49, 115, 27, 361), + Trans(49, 116, 27, 361), + Trans(49, 117, 27, 361), + Trans(50, 5, 27, 361), + Trans(50, 15, 27, 361), + Trans(50, 16, 27, 361), + Trans(50, 17, 27, 361), + Trans(50, 18, 27, 361), + Trans(50, 19, 27, 361), + Trans(50, 20, 27, 361), + Trans(50, 21, 27, 361), + Trans(50, 22, 27, 361), + Trans(50, 23, 27, 361), + Trans(50, 24, 27, 361), + Trans(50, 25, 27, 361), + Trans(50, 26, 27, 361), + Trans(50, 30, 27, 361), + Trans(50, 31, 27, 361), + Trans(50, 32, 27, 361), + Trans(50, 33, 27, 361), + Trans(50, 34, 27, 361), + Trans(50, 35, 27, 361), + Trans(50, 36, 27, 361), + Trans(50, 41, 27, 361), + Trans(50, 42, 27, 361), + Trans(50, 44, 27, 361), + Trans(50, 48, 27, 361), + Trans(50, 52, 27, 361), + Trans(51, 5, 27, 361), + Trans(51, 15, 27, 361), + Trans(51, 16, 27, 361), + Trans(51, 17, 27, 361), + Trans(51, 18, 27, 361), + Trans(51, 19, 27, 361), + Trans(51, 20, 27, 361), + Trans(51, 21, 27, 361), + Trans(51, 22, 27, 361), + Trans(51, 23, 27, 361), + Trans(51, 24, 27, 361), + Trans(51, 25, 27, 361), + Trans(51, 26, 27, 361), + Trans(51, 29, 27, 361), + Trans(51, 30, 27, 361), + Trans(51, 31, 27, 361), + Trans(51, 32, 27, 361), + Trans(51, 33, 27, 361), + Trans(51, 34, 27, 361), + Trans(51, 35, 27, 361), + Trans(51, 36, 27, 361), + Trans(51, 41, 27, 361), + Trans(51, 42, 27, 361), + Trans(51, 44, 27, 361), + Trans(51, 48, 27, 361), + Trans(51, 52, 27, 361), + Trans(52, 12, 27, 361), + Trans(52, 14, 27, 361), + Trans(52, 16, 27, 361), + Trans(52, 17, 27, 361), + Trans(52, 18, 27, 361), + Trans(52, 19, 27, 361), + Trans(52, 20, 27, 361), + Trans(52, 21, 27, 361), + Trans(52, 22, 27, 361), + Trans(52, 23, 27, 361), + Trans(52, 24, 27, 361), + Trans(52, 25, 27, 361), + Trans(52, 26, 27, 361), + Trans(52, 31, 27, 361), + Trans(52, 32, 27, 361), + Trans(52, 33, 27, 361), + Trans(52, 34, 27, 361), + Trans(52, 37, 27, 361), + Trans(52, 40, 27, 361), + Trans(52, 43, 27, 361), + Trans(52, 44, 27, 361), + Trans(52, 45, 27, 361), + Trans(52, 46, 27, 361), + Trans(52, 47, 27, 361), + Trans(52, 48, 27, 361), + Trans(52, 49, 27, 361), + Trans(52, 50, 27, 361), + Trans(52, 51, 27, 361), + Trans(52, 52, 27, 361), + Trans(52, 60, 27, 361), + Trans(52, 62, 27, 361), + Trans(52, 63, 27, 361), + Trans(52, 66, 27, 361), + Trans(52, 67, 27, 361), + Trans(52, 68, 27, 361), + Trans(52, 72, 27, 361), + Trans(52, 73, 27, 361), + Trans(52, 75, 27, 361), + Trans(52, 79, 27, 361), + Trans(52, 82, 27, 361), + Trans(52, 83, 27, 361), + Trans(52, 86, 27, 361), + Trans(52, 96, 27, 361), + Trans(52, 105, 27, 361), + Trans(52, 107, 27, 361), + Trans(52, 110, 27, 361), + Trans(52, 113, 27, 361), + Trans(52, 114, 27, 361), + Trans(52, 115, 27, 361), + Trans(53, 5, 27, 361), + Trans(53, 6, 27, 361), + Trans(53, 7, 27, 361), + Trans(53, 8, 27, 361), + Trans(53, 9, 27, 361), + Trans(53, 10, 27, 361), + Trans(53, 11, 27, 361), + Trans(53, 18, 27, 361), + Trans(53, 24, 27, 361), + Trans(53, 25, 27, 361), + Trans(53, 26, 27, 361), + Trans(53, 27, 27, 361), + Trans(53, 39, 27, 361), + Trans(53, 40, 27, 361), + Trans(53, 42, 27, 361), + Trans(53, 54, 27, 361), + Trans(53, 67, 27, 361), + Trans(53, 71, 27, 361), + Trans(53, 72, 27, 361), + Trans(53, 78, 27, 361), + Trans(53, 82, 27, 361), + Trans(53, 85, 27, 361), + Trans(53, 88, 27, 361), + Trans(53, 90, 27, 361), + Trans(53, 102, 27, 361), + Trans(53, 103, 27, 361), + Trans(53, 108, 27, 361), + Trans(53, 116, 27, 361), + Trans(53, 117, 27, 361), + Trans(54, 5, 27, 361), + Trans(54, 6, 27, 361), + Trans(54, 7, 27, 361), + Trans(54, 8, 27, 361), + Trans(54, 9, 27, 361), + Trans(54, 10, 27, 361), + Trans(54, 11, 27, 361), + Trans(54, 18, 27, 361), + Trans(54, 24, 27, 361), + Trans(54, 25, 27, 361), + Trans(54, 26, 27, 361), + Trans(54, 27, 27, 361), + Trans(54, 37, 27, 361), + Trans(54, 39, 27, 361), + Trans(54, 40, 27, 361), + Trans(54, 42, 27, 361), + Trans(54, 44, 27, 361), + Trans(54, 46, 27, 361), + Trans(54, 54, 27, 361), + Trans(54, 59, 27, 361), + Trans(54, 72, 27, 361), + Trans(54, 78, 27, 361), + Trans(54, 83, 27, 361), + Trans(54, 85, 27, 361), + Trans(54, 88, 27, 361), + Trans(54, 90, 27, 361), + Trans(54, 92, 27, 361), + Trans(54, 108, 27, 361), + Trans(54, 116, 27, 361), + Trans(54, 117, 27, 361), + Trans(55, 5, 27, 361), + Trans(55, 6, 27, 361), + Trans(55, 7, 27, 361), + Trans(55, 8, 27, 361), + Trans(55, 9, 27, 361), + Trans(55, 10, 27, 361), + Trans(55, 11, 27, 361), + Trans(55, 18, 27, 361), + Trans(55, 24, 27, 361), + Trans(55, 25, 27, 361), + Trans(55, 26, 27, 361), + Trans(55, 27, 27, 361), + Trans(55, 31, 27, 361), + Trans(55, 37, 27, 361), + Trans(55, 39, 27, 361), + Trans(55, 40, 27, 361), + Trans(55, 42, 27, 361), + Trans(55, 44, 27, 361), + Trans(55, 49, 27, 361), + Trans(55, 50, 27, 361), + Trans(55, 51, 27, 361), + Trans(55, 54, 27, 361), + Trans(55, 59, 27, 361), + Trans(55, 62, 27, 361), + Trans(55, 63, 27, 361), + Trans(55, 66, 27, 361), + Trans(55, 67, 27, 361), + Trans(55, 68, 27, 361), + Trans(55, 71, 27, 361), + Trans(55, 72, 27, 361), + Trans(55, 73, 27, 361), + Trans(55, 75, 27, 361), + Trans(55, 78, 27, 361), + Trans(55, 79, 27, 361), + Trans(55, 82, 27, 361), + Trans(55, 83, 27, 361), + Trans(55, 85, 27, 361), + Trans(55, 86, 27, 361), + Trans(55, 88, 27, 361), + Trans(55, 90, 27, 361), + Trans(55, 102, 27, 361), + Trans(55, 103, 27, 361), + Trans(55, 107, 27, 361), + Trans(55, 108, 27, 361), + Trans(55, 110, 27, 361), + Trans(55, 113, 27, 361), + Trans(55, 114, 27, 361), + Trans(55, 115, 27, 361), + Trans(55, 116, 27, 361), + Trans(55, 117, 27, 361), + Trans(56, 5, 27, 361), + Trans(56, 32, 27, 361), + Trans(56, 36, 27, 361), + Trans(56, 40, 27, 361), + Trans(56, 41, 27, 361), + Trans(56, 44, 27, 361), + Trans(56, 46, 27, 361), + Trans(56, 47, 27, 361), + Trans(56, 81, 27, 361), + Trans(57, 0, 27, 361), + Trans(57, 5, 27, 361), + Trans(57, 12, 27, 361), + Trans(57, 14, 27, 361), + Trans(57, 16, 27, 361), + Trans(57, 17, 27, 361), + Trans(57, 18, 27, 361), + Trans(57, 19, 27, 361), + Trans(57, 20, 27, 361), + Trans(57, 21, 27, 361), + Trans(57, 22, 27, 361), + Trans(57, 23, 27, 361), + Trans(57, 24, 27, 361), + Trans(57, 25, 27, 361), + Trans(57, 26, 27, 361), + Trans(57, 31, 27, 361), + Trans(57, 32, 27, 361), + Trans(57, 33, 27, 361), + Trans(57, 34, 27, 361), + Trans(57, 37, 27, 361), + Trans(57, 40, 27, 361), + Trans(57, 43, 27, 361), + Trans(57, 44, 27, 361), + Trans(57, 45, 27, 361), + Trans(57, 46, 27, 361), + Trans(57, 47, 27, 361), + Trans(57, 48, 27, 361), + Trans(57, 49, 27, 361), + Trans(57, 50, 27, 361), + Trans(57, 51, 27, 361), + Trans(57, 52, 27, 361), + Trans(57, 60, 27, 361), + Trans(57, 61, 27, 361), + Trans(57, 62, 27, 361), + Trans(57, 63, 27, 361), + Trans(57, 66, 27, 361), + Trans(57, 67, 27, 361), + Trans(57, 68, 27, 361), + Trans(57, 72, 27, 361), + Trans(57, 73, 27, 361), + Trans(57, 74, 27, 361), + Trans(57, 75, 27, 361), + Trans(57, 79, 27, 361), + Trans(57, 80, 27, 361), + Trans(57, 82, 27, 361), + Trans(57, 83, 27, 361), + Trans(57, 86, 27, 361), + Trans(57, 87, 27, 361), + Trans(57, 91, 27, 361), + Trans(57, 93, 27, 361), + Trans(57, 94, 27, 361), + Trans(57, 96, 27, 361), + Trans(57, 105, 27, 361), + Trans(57, 107, 27, 361), + Trans(57, 110, 27, 361), + Trans(57, 113, 27, 361), + Trans(57, 114, 27, 361), + Trans(57, 115, 27, 361), + Trans(58, 5, 27, 361), + Trans(58, 12, 27, 361), + Trans(58, 14, 27, 361), + Trans(58, 15, 27, 361), + Trans(58, 16, 27, 361), + Trans(58, 17, 27, 361), + Trans(58, 18, 27, 361), + Trans(58, 19, 27, 361), + Trans(58, 20, 27, 361), + Trans(58, 21, 27, 361), + Trans(58, 22, 27, 361), + Trans(58, 23, 27, 361), + Trans(58, 24, 27, 361), + Trans(58, 25, 27, 361), + Trans(58, 26, 27, 361), + Trans(58, 31, 27, 361), + Trans(58, 32, 27, 361), + Trans(58, 33, 27, 361), + Trans(58, 34, 27, 361), + Trans(58, 35, 27, 361), + Trans(58, 36, 27, 361), + Trans(58, 37, 27, 361), + Trans(58, 40, 27, 361), + Trans(58, 41, 27, 361), + Trans(58, 42, 27, 361), + Trans(58, 43, 27, 361), + Trans(58, 44, 27, 361), + Trans(58, 45, 27, 361), + Trans(58, 46, 27, 361), + Trans(58, 47, 27, 361), + Trans(58, 48, 27, 361), + Trans(58, 52, 27, 361), + Trans(58, 96, 27, 361), + Trans(58, 105, 27, 361), + Trans(59, 5, 27, 361), + Trans(59, 12, 27, 361), + Trans(59, 13, 27, 361), + Trans(59, 14, 27, 361), + Trans(59, 16, 27, 361), + Trans(59, 17, 27, 361), + Trans(59, 18, 27, 361), + Trans(59, 19, 27, 361), + Trans(59, 20, 27, 361), + Trans(59, 21, 27, 361), + Trans(59, 22, 27, 361), + Trans(59, 23, 27, 361), + Trans(59, 24, 27, 361), + Trans(59, 25, 27, 361), + Trans(59, 26, 27, 361), + Trans(59, 31, 27, 361), + Trans(59, 32, 27, 361), + Trans(59, 33, 27, 361), + Trans(59, 34, 27, 361), + Trans(59, 40, 27, 361), + Trans(59, 42, 27, 361), + Trans(59, 43, 27, 361), + Trans(59, 44, 27, 361), + Trans(59, 45, 27, 361), + Trans(59, 46, 27, 361), + Trans(59, 47, 27, 361), + Trans(59, 48, 27, 361), + Trans(59, 52, 27, 361), + Trans(59, 96, 27, 361), + Trans(59, 105, 27, 361), + Trans(60, 5, 27, 361), + Trans(60, 55, 27, 361), + Trans(60, 56, 27, 361), + Trans(60, 57, 27, 361), + Trans(60, 64, 27, 361), + Trans(60, 65, 27, 361), + Trans(60, 69, 27, 361), + Trans(60, 70, 27, 361), + Trans(60, 97, 27, 361), + Trans(60, 98, 27, 361), + Trans(60, 99, 27, 361), + Trans(60, 100, 27, 361), + Trans(60, 101, 27, 361), + Trans(60, 111, 27, 361), + Trans(60, 112, 27, 361), + Trans(60, 116, 27, 361), + Trans(60, 117, 27, 361), + Trans(61, 5, 27, 361), + Trans(61, 40, 27, 361), + Trans(61, 72, 27, 361), + Trans(62, 5, 27, 361), + Trans(62, 6, 27, 361), + Trans(62, 7, 27, 361), + Trans(62, 8, 27, 361), + Trans(62, 9, 27, 361), + Trans(62, 10, 27, 361), + Trans(62, 11, 27, 361), + Trans(62, 15, 27, 361), + Trans(62, 18, 27, 361), + Trans(62, 24, 27, 361), + Trans(62, 25, 27, 361), + Trans(62, 26, 27, 361), + Trans(62, 27, 27, 361), + Trans(62, 39, 27, 361), + Trans(62, 40, 27, 361), + Trans(62, 42, 27, 361), + Trans(62, 54, 27, 361), + Trans(62, 72, 27, 361), + Trans(62, 78, 27, 361), + Trans(62, 85, 27, 361), + Trans(62, 88, 27, 361), + Trans(62, 90, 27, 361), + Trans(62, 108, 27, 361), + Trans(62, 116, 27, 361), + Trans(62, 117, 27, 361), + Trans(63, 12, 27, 361), + Trans(63, 13, 27, 361), + Trans(63, 14, 27, 361), + Trans(63, 15, 27, 361), + Trans(63, 16, 27, 361), + Trans(63, 17, 27, 361), + Trans(63, 18, 27, 361), + Trans(63, 19, 27, 361), + Trans(63, 20, 27, 361), + Trans(63, 21, 27, 361), + Trans(63, 22, 27, 361), + Trans(63, 23, 27, 361), + Trans(63, 24, 27, 361), + Trans(63, 25, 27, 361), + Trans(63, 26, 27, 361), + Trans(63, 30, 27, 361), + Trans(63, 31, 27, 361), + Trans(63, 32, 27, 361), + Trans(63, 33, 27, 361), + Trans(63, 34, 27, 361), + Trans(63, 35, 27, 361), + Trans(63, 36, 27, 361), + Trans(63, 37, 27, 361), + Trans(63, 38, 27, 361), + Trans(63, 40, 27, 361), + Trans(63, 41, 27, 361), + Trans(63, 42, 27, 361), + Trans(63, 43, 27, 361), + Trans(63, 44, 27, 361), + Trans(63, 45, 27, 361), + Trans(63, 46, 27, 361), + Trans(63, 47, 27, 361), + Trans(63, 48, 27, 361), + Trans(63, 52, 27, 361), + Trans(63, 67, 27, 361), + Trans(63, 81, 27, 361), + Trans(63, 96, 27, 361), + Trans(63, 105, 27, 361), + Trans(64, 5, 27, 361), + Trans(64, 53, 27, 361), + Trans(64, 55, 27, 361), + Trans(64, 56, 27, 361), + Trans(64, 57, 27, 361), + Trans(64, 64, 27, 361), + Trans(64, 65, 27, 361), + Trans(64, 69, 27, 361), + Trans(64, 70, 27, 361), + Trans(64, 84, 27, 361), + Trans(64, 97, 27, 361), + Trans(64, 98, 27, 361), + Trans(64, 99, 27, 361), + Trans(64, 100, 27, 361), + Trans(64, 101, 27, 361), + Trans(64, 104, 27, 361), + Trans(64, 106, 27, 361), + Trans(64, 109, 27, 361), + Trans(64, 111, 27, 361), + Trans(64, 112, 27, 361), + Trans(64, 116, 27, 361), + Trans(64, 117, 27, 361), + Trans(65, 5, 27, 361), + Trans(65, 48, 27, 361), + Trans(65, 117, 27, 361), + Trans(66, 5, 27, 361), + Trans(66, 6, 27, 361), + Trans(66, 7, 27, 361), + Trans(66, 8, 27, 361), + Trans(66, 9, 27, 361), + Trans(66, 10, 27, 361), + Trans(66, 11, 27, 361), + Trans(66, 18, 27, 361), + Trans(66, 24, 27, 361), + Trans(66, 25, 27, 361), + Trans(66, 26, 27, 361), + Trans(66, 27, 27, 361), + Trans(66, 37, 27, 361), + Trans(66, 39, 27, 361), + Trans(66, 40, 27, 361), + Trans(66, 42, 27, 361), + Trans(66, 43, 27, 361), + Trans(66, 44, 27, 361), + Trans(66, 46, 27, 361), + Trans(66, 54, 27, 361), + Trans(66, 59, 27, 361), + Trans(66, 72, 27, 361), + Trans(66, 78, 27, 361), + Trans(66, 83, 27, 361), + Trans(66, 85, 27, 361), + Trans(66, 88, 27, 361), + Trans(66, 90, 27, 361), + Trans(66, 92, 27, 361), + Trans(66, 108, 27, 361), + Trans(66, 116, 27, 361), + Trans(66, 117, 27, 361), + Trans(67, 5, 27, 361), + Trans(67, 6, 27, 361), + Trans(67, 7, 27, 361), + Trans(67, 8, 27, 361), + Trans(67, 9, 27, 361), + Trans(67, 10, 27, 361), + Trans(67, 11, 27, 361), + Trans(67, 18, 27, 361), + Trans(67, 24, 27, 361), + Trans(67, 25, 27, 361), + Trans(67, 26, 27, 361), + Trans(67, 27, 27, 361), + Trans(67, 37, 27, 361), + Trans(67, 39, 27, 361), + Trans(67, 40, 27, 361), + Trans(67, 42, 27, 361), + Trans(67, 46, 27, 361), + Trans(67, 54, 27, 361), + Trans(67, 72, 27, 361), + Trans(67, 78, 27, 361), + Trans(67, 85, 27, 361), + Trans(67, 88, 27, 361), + Trans(67, 90, 27, 361), + Trans(67, 108, 27, 361), + Trans(67, 116, 27, 361), + Trans(67, 117, 27, 361), + Trans(68, 5, 27, 361), + Trans(68, 12, 27, 361), + Trans(68, 13, 27, 361), + Trans(68, 14, 27, 361), + Trans(68, 15, 27, 361), + Trans(68, 16, 27, 361), + Trans(68, 17, 27, 361), + Trans(68, 18, 27, 361), + Trans(68, 19, 27, 361), + Trans(68, 20, 27, 361), + Trans(68, 21, 27, 361), + Trans(68, 22, 27, 361), + Trans(68, 23, 27, 361), + Trans(68, 24, 27, 361), + Trans(68, 25, 27, 361), + Trans(68, 26, 27, 361), + Trans(68, 30, 27, 361), + Trans(68, 31, 27, 361), + Trans(68, 32, 27, 361), + Trans(68, 33, 27, 361), + Trans(68, 34, 27, 361), + Trans(68, 35, 27, 361), + Trans(68, 36, 27, 361), + Trans(68, 37, 27, 361), + Trans(68, 38, 27, 361), + Trans(68, 40, 27, 361), + Trans(68, 41, 27, 361), + Trans(68, 42, 27, 361), + Trans(68, 43, 27, 361), + Trans(68, 44, 27, 361), + Trans(68, 45, 27, 361), + Trans(68, 46, 27, 361), + Trans(68, 47, 27, 361), + Trans(68, 48, 27, 361), + Trans(68, 52, 27, 361), + Trans(68, 67, 27, 361), + Trans(68, 81, 27, 361), + Trans(68, 96, 27, 361), + Trans(68, 105, 27, 361), + Trans(69, 5, 27, 361), + Trans(69, 12, 27, 361), + Trans(69, 14, 27, 361), + Trans(69, 16, 27, 361), + Trans(69, 17, 27, 361), + Trans(69, 18, 27, 361), + Trans(69, 19, 27, 361), + Trans(69, 20, 27, 361), + Trans(69, 21, 27, 361), + Trans(69, 22, 27, 361), + Trans(69, 23, 27, 361), + Trans(69, 24, 27, 361), + Trans(69, 25, 27, 361), + Trans(69, 26, 27, 361), + Trans(69, 31, 27, 361), + Trans(69, 32, 27, 361), + Trans(69, 33, 27, 361), + Trans(69, 34, 27, 361), + Trans(69, 37, 27, 361), + Trans(69, 40, 27, 361), + Trans(69, 43, 27, 361), + Trans(69, 44, 27, 361), + Trans(69, 45, 27, 361), + Trans(69, 46, 27, 361), + Trans(69, 47, 27, 361), + Trans(69, 48, 27, 361), + Trans(69, 49, 27, 361), + Trans(69, 50, 27, 361), + Trans(69, 51, 27, 361), + Trans(69, 52, 27, 361), + Trans(69, 60, 27, 361), + Trans(69, 62, 27, 361), + Trans(69, 63, 27, 361), + Trans(69, 66, 27, 361), + Trans(69, 67, 27, 361), + Trans(69, 68, 27, 361), + Trans(69, 72, 27, 361), + Trans(69, 73, 27, 361), + Trans(69, 75, 27, 361), + Trans(69, 79, 27, 361), + Trans(69, 82, 27, 361), + Trans(69, 83, 27, 361), + Trans(69, 86, 27, 361), + Trans(69, 96, 27, 361), + Trans(69, 105, 27, 361), + Trans(69, 107, 27, 361), + Trans(69, 110, 27, 361), + Trans(69, 113, 27, 361), + Trans(69, 114, 27, 361), + Trans(69, 115, 27, 361), + Trans(70, 0, 27, 361), + Trans(70, 5, 27, 361), + Trans(70, 6, 27, 361), + Trans(70, 7, 27, 361), + Trans(70, 8, 27, 361), + Trans(70, 9, 27, 361), + Trans(70, 10, 27, 361), + Trans(70, 11, 27, 361), + Trans(70, 18, 27, 361), + Trans(70, 24, 27, 361), + Trans(70, 25, 27, 361), + Trans(70, 26, 27, 361), + Trans(70, 27, 27, 361), + Trans(70, 31, 27, 361), + Trans(70, 37, 27, 361), + Trans(70, 39, 27, 361), + Trans(70, 40, 27, 361), + Trans(70, 42, 27, 361), + Trans(70, 44, 27, 361), + Trans(70, 49, 27, 361), + Trans(70, 50, 27, 361), + Trans(70, 51, 27, 361), + Trans(70, 54, 27, 361), + Trans(70, 59, 27, 361), + Trans(70, 61, 27, 361), + Trans(70, 62, 27, 361), + Trans(70, 63, 27, 361), + Trans(70, 66, 27, 361), + Trans(70, 67, 27, 361), + Trans(70, 68, 27, 361), + Trans(70, 71, 27, 361), + Trans(70, 72, 27, 361), + Trans(70, 73, 27, 361), + Trans(70, 74, 27, 361), + Trans(70, 75, 27, 361), + Trans(70, 78, 27, 361), + Trans(70, 79, 27, 361), + Trans(70, 80, 27, 361), + Trans(70, 82, 27, 361), + Trans(70, 83, 27, 361), + Trans(70, 85, 27, 361), + Trans(70, 86, 27, 361), + Trans(70, 87, 27, 361), + Trans(70, 88, 27, 361), + Trans(70, 90, 27, 361), + Trans(70, 91, 27, 361), + Trans(70, 93, 27, 361), + Trans(70, 94, 27, 361), + Trans(70, 102, 27, 361), + Trans(70, 103, 27, 361), + Trans(70, 107, 27, 361), + Trans(70, 108, 27, 361), + Trans(70, 110, 27, 361), + Trans(70, 113, 27, 361), + Trans(70, 114, 27, 361), + Trans(70, 115, 27, 361), + Trans(70, 116, 27, 361), + Trans(70, 117, 27, 361), + Trans(71, 12, 27, 361), + Trans(71, 13, 27, 361), + Trans(71, 14, 27, 361), + Trans(71, 16, 27, 361), + Trans(71, 17, 27, 361), + Trans(71, 18, 27, 361), + Trans(71, 19, 27, 361), + Trans(71, 20, 27, 361), + Trans(71, 21, 27, 361), + Trans(71, 22, 27, 361), + Trans(71, 23, 27, 361), + Trans(71, 24, 27, 361), + Trans(71, 25, 27, 361), + Trans(71, 26, 27, 361), + Trans(71, 31, 27, 361), + Trans(71, 32, 27, 361), + Trans(71, 33, 27, 361), + Trans(71, 34, 27, 361), + Trans(71, 40, 27, 361), + Trans(71, 42, 27, 361), + Trans(71, 43, 27, 361), + Trans(71, 44, 27, 361), + Trans(71, 45, 27, 361), + Trans(71, 46, 27, 361), + Trans(71, 47, 27, 361), + Trans(71, 48, 27, 361), + Trans(71, 52, 27, 361), + Trans(71, 96, 27, 361), + Trans(71, 105, 27, 361), + Trans(72, 5, 27, 361), + Trans(72, 6, 27, 361), + Trans(72, 7, 27, 361), + Trans(72, 8, 27, 361), + Trans(72, 9, 27, 361), + Trans(72, 10, 27, 361), + Trans(72, 11, 27, 361), + Trans(72, 18, 27, 361), + Trans(72, 24, 27, 361), + Trans(72, 25, 27, 361), + Trans(72, 26, 27, 361), + Trans(72, 27, 27, 361), + Trans(72, 31, 27, 361), + Trans(72, 37, 27, 361), + Trans(72, 39, 27, 361), + Trans(72, 40, 27, 361), + Trans(72, 42, 27, 361), + Trans(72, 44, 27, 361), + Trans(72, 49, 27, 361), + Trans(72, 50, 27, 361), + Trans(72, 51, 27, 361), + Trans(72, 54, 27, 361), + Trans(72, 59, 27, 361), + Trans(72, 62, 27, 361), + Trans(72, 66, 27, 361), + Trans(72, 67, 27, 361), + Trans(72, 68, 27, 361), + Trans(72, 71, 27, 361), + Trans(72, 72, 27, 361), + Trans(72, 73, 27, 361), + Trans(72, 75, 27, 361), + Trans(72, 78, 27, 361), + Trans(72, 79, 27, 361), + Trans(72, 82, 27, 361), + Trans(72, 83, 27, 361), + Trans(72, 85, 27, 361), + Trans(72, 86, 27, 361), + Trans(72, 88, 27, 361), + Trans(72, 90, 27, 361), + Trans(72, 102, 27, 361), + Trans(72, 103, 27, 361), + Trans(72, 107, 27, 361), + Trans(72, 108, 27, 361), + Trans(72, 110, 27, 361), + Trans(72, 113, 27, 361), + Trans(72, 114, 27, 361), + Trans(72, 115, 27, 361), + Trans(72, 116, 27, 361), + Trans(72, 117, 27, 361), + Trans(73, 5, 27, 361), + Trans(73, 37, 27, 361), + Trans(73, 40, 27, 361), + Trans(73, 46, 27, 361), + Trans(73, 117, 27, 361), + Trans(74, 5, 27, 361), + Trans(74, 12, 27, 361), + Trans(74, 14, 27, 361), + Trans(74, 16, 27, 361), + Trans(74, 17, 27, 361), + Trans(74, 18, 27, 361), + Trans(74, 19, 27, 361), + Trans(74, 20, 27, 361), + Trans(74, 21, 27, 361), + Trans(74, 22, 27, 361), + Trans(74, 23, 27, 361), + Trans(74, 24, 27, 361), + Trans(74, 25, 27, 361), + Trans(74, 26, 27, 361), + Trans(74, 31, 27, 361), + Trans(74, 32, 27, 361), + Trans(74, 33, 27, 361), + Trans(74, 34, 27, 361), + Trans(74, 40, 27, 361), + Trans(74, 42, 27, 361), + Trans(74, 43, 27, 361), + Trans(74, 44, 27, 361), + Trans(74, 45, 27, 361), + Trans(74, 46, 27, 361), + Trans(74, 47, 27, 361), + Trans(74, 48, 27, 361), + Trans(74, 52, 27, 361), + Trans(74, 96, 27, 361), + Trans(74, 105, 27, 361), + Trans(75, 6, 27, 361), + Trans(75, 7, 27, 361), + Trans(75, 8, 27, 361), + Trans(75, 9, 27, 361), + Trans(75, 10, 27, 361), + Trans(75, 11, 27, 361), + Trans(75, 18, 27, 361), + Trans(75, 24, 27, 361), + Trans(75, 25, 27, 361), + Trans(75, 26, 27, 361), + Trans(75, 27, 27, 361), + Trans(75, 39, 27, 361), + Trans(75, 40, 27, 361), + Trans(75, 42, 27, 361), + Trans(75, 54, 27, 361), + Trans(75, 72, 27, 361), + Trans(75, 78, 27, 361), + Trans(75, 85, 27, 361), + Trans(75, 88, 27, 361), + Trans(75, 90, 27, 361), + Trans(75, 108, 27, 361), + Trans(75, 116, 27, 361), + Trans(75, 117, 27, 361), + Trans(76, 5, 27, 361), + Trans(76, 16, 27, 361), + Trans(76, 17, 27, 361), + Trans(76, 18, 27, 361), + Trans(76, 19, 27, 361), + Trans(76, 20, 27, 361), + Trans(76, 21, 27, 361), + Trans(76, 22, 27, 361), + Trans(76, 23, 27, 361), + Trans(76, 24, 27, 361), + Trans(76, 25, 27, 361), + Trans(76, 26, 27, 361), + Trans(76, 45, 27, 361), + Trans(76, 48, 27, 361), + Trans(76, 52, 27, 361), + Trans(77, 5, 27, 361), + Trans(77, 16, 27, 361), + Trans(77, 17, 27, 361), + Trans(77, 18, 27, 361), + Trans(77, 19, 27, 361), + Trans(77, 20, 27, 361), + Trans(77, 21, 27, 361), + Trans(77, 22, 27, 361), + Trans(77, 23, 27, 361), + Trans(77, 24, 27, 361), + Trans(77, 25, 27, 361), + Trans(77, 26, 27, 361), + Trans(77, 30, 27, 361), + Trans(77, 35, 27, 361), + Trans(77, 41, 27, 361), + Trans(77, 42, 27, 361), + Trans(77, 45, 27, 361), + Trans(77, 48, 27, 361), + Trans(77, 52, 27, 361), + Trans(78, 5, 27, 361), + Trans(78, 16, 27, 361), + Trans(78, 17, 27, 361), + Trans(78, 18, 27, 361), + Trans(78, 19, 27, 361), + Trans(78, 20, 27, 361), + Trans(78, 21, 27, 361), + Trans(78, 22, 27, 361), + Trans(78, 23, 27, 361), + Trans(78, 24, 27, 361), + Trans(78, 25, 27, 361), + Trans(78, 26, 27, 361), + Trans(78, 29, 27, 361), + Trans(78, 30, 27, 361), + Trans(78, 35, 27, 361), + Trans(78, 41, 27, 361), + Trans(78, 42, 27, 361), + Trans(78, 45, 27, 361), + Trans(78, 48, 27, 361), + Trans(78, 52, 27, 361), + Trans(79, 5, 27, 361), + Trans(79, 16, 27, 361), + Trans(79, 17, 27, 361), + Trans(79, 18, 27, 361), + Trans(79, 19, 27, 361), + Trans(79, 20, 27, 361), + Trans(79, 21, 27, 361), + Trans(79, 22, 27, 361), + Trans(79, 23, 27, 361), + Trans(79, 24, 27, 361), + Trans(79, 25, 27, 361), + Trans(79, 26, 27, 361), + Trans(79, 47, 27, 361), + Trans(79, 48, 27, 361), + Trans(79, 52, 27, 361), + Trans(80, 5, 27, 361), + Trans(80, 16, 27, 361), + Trans(80, 17, 27, 361), + Trans(80, 18, 27, 361), + Trans(80, 19, 27, 361), + Trans(80, 20, 27, 361), + Trans(80, 21, 27, 361), + Trans(80, 22, 27, 361), + Trans(80, 23, 27, 361), + Trans(80, 24, 27, 361), + Trans(80, 25, 27, 361), + Trans(80, 26, 27, 361), + Trans(80, 30, 27, 361), + Trans(80, 35, 27, 361), + Trans(80, 41, 27, 361), + Trans(80, 42, 27, 361), + Trans(80, 47, 27, 361), + Trans(80, 48, 27, 361), + Trans(80, 52, 27, 361), + Trans(81, 5, 27, 361), + Trans(81, 16, 27, 361), + Trans(81, 17, 27, 361), + Trans(81, 18, 27, 361), + Trans(81, 19, 27, 361), + Trans(81, 20, 27, 361), + Trans(81, 21, 27, 361), + Trans(81, 22, 27, 361), + Trans(81, 23, 27, 361), + Trans(81, 24, 27, 361), + Trans(81, 25, 27, 361), + Trans(81, 26, 27, 361), + Trans(81, 29, 27, 361), + Trans(81, 30, 27, 361), + Trans(81, 35, 27, 361), + Trans(81, 41, 27, 361), + Trans(81, 42, 27, 361), + Trans(81, 47, 27, 361), + Trans(81, 48, 27, 361), + Trans(81, 52, 27, 361), + Trans(82, 5, 27, 361), + Trans(82, 12, 27, 361), + Trans(82, 14, 27, 361), + Trans(82, 16, 27, 361), + Trans(82, 17, 27, 361), + Trans(82, 18, 27, 361), + Trans(82, 19, 27, 361), + Trans(82, 20, 27, 361), + Trans(82, 21, 27, 361), + Trans(82, 22, 27, 361), + Trans(82, 23, 27, 361), + Trans(82, 24, 27, 361), + Trans(82, 25, 27, 361), + Trans(82, 26, 27, 361), + Trans(82, 31, 27, 361), + Trans(82, 32, 27, 361), + Trans(82, 33, 27, 361), + Trans(82, 34, 27, 361), + Trans(82, 40, 27, 361), + Trans(82, 43, 27, 361), + Trans(82, 44, 27, 361), + Trans(82, 45, 27, 361), + Trans(82, 46, 27, 361), + Trans(82, 47, 27, 361), + Trans(82, 48, 27, 361), + Trans(82, 52, 27, 361), + Trans(82, 96, 27, 361), + Trans(82, 105, 27, 361), + Trans(83, 5, 27, 361), + Trans(83, 12, 27, 361), + Trans(83, 14, 27, 361), + Trans(83, 16, 27, 361), + Trans(83, 17, 27, 361), + Trans(83, 18, 27, 361), + Trans(83, 19, 27, 361), + Trans(83, 20, 27, 361), + Trans(83, 21, 27, 361), + Trans(83, 22, 27, 361), + Trans(83, 23, 27, 361), + Trans(83, 24, 27, 361), + Trans(83, 25, 27, 361), + Trans(83, 26, 27, 361), + Trans(83, 30, 27, 361), + Trans(83, 31, 27, 361), + Trans(83, 32, 27, 361), + Trans(83, 33, 27, 361), + Trans(83, 34, 27, 361), + Trans(83, 35, 27, 361), + Trans(83, 40, 27, 361), + Trans(83, 41, 27, 361), + Trans(83, 42, 27, 361), + Trans(83, 43, 27, 361), + Trans(83, 44, 27, 361), + Trans(83, 45, 27, 361), + Trans(83, 46, 27, 361), + Trans(83, 47, 27, 361), + Trans(83, 48, 27, 361), + Trans(83, 52, 27, 361), + Trans(83, 96, 27, 361), + Trans(83, 105, 27, 361), + Trans(84, 5, 27, 361), + Trans(84, 12, 27, 361), + Trans(84, 14, 27, 361), + Trans(84, 16, 27, 361), + Trans(84, 17, 27, 361), + Trans(84, 18, 27, 361), + Trans(84, 19, 27, 361), + Trans(84, 20, 27, 361), + Trans(84, 21, 27, 361), + Trans(84, 22, 27, 361), + Trans(84, 23, 27, 361), + Trans(84, 24, 27, 361), + Trans(84, 25, 27, 361), + Trans(84, 26, 27, 361), + Trans(84, 29, 27, 361), + Trans(84, 30, 27, 361), + Trans(84, 31, 27, 361), + Trans(84, 32, 27, 361), + Trans(84, 33, 27, 361), + Trans(84, 34, 27, 361), + Trans(84, 35, 27, 361), + Trans(84, 40, 27, 361), + Trans(84, 41, 27, 361), + Trans(84, 42, 27, 361), + Trans(84, 43, 27, 361), + Trans(84, 44, 27, 361), + Trans(84, 45, 27, 361), + Trans(84, 46, 27, 361), + Trans(84, 47, 27, 361), + Trans(84, 48, 27, 361), + Trans(84, 52, 27, 361), + Trans(84, 96, 27, 361), + Trans(84, 105, 27, 361), + Trans(85, 6, 27, 361), + Trans(85, 7, 27, 361), + Trans(85, 8, 27, 361), + Trans(85, 9, 27, 361), + Trans(85, 10, 27, 361), + Trans(85, 11, 27, 361), + Trans(85, 18, 27, 361), + Trans(85, 24, 27, 361), + Trans(85, 25, 27, 361), + Trans(85, 26, 27, 361), + Trans(85, 27, 27, 361), + Trans(85, 39, 27, 361), + Trans(85, 40, 27, 361), + Trans(85, 42, 27, 361), + Trans(85, 54, 27, 361), + Trans(85, 67, 27, 361), + Trans(85, 71, 27, 361), + Trans(85, 72, 27, 361), + Trans(85, 78, 27, 361), + Trans(85, 82, 27, 361), + Trans(85, 85, 27, 361), + Trans(85, 88, 27, 361), + Trans(85, 90, 27, 361), + Trans(85, 102, 27, 361), + Trans(85, 103, 27, 361), + Trans(85, 108, 27, 361), + Trans(85, 116, 27, 361), + Trans(85, 117, 27, 361), + Trans(86, 5, 27, 361), + Trans(86, 16, 27, 361), + Trans(86, 17, 27, 361), + Trans(86, 18, 27, 361), + Trans(86, 19, 27, 361), + Trans(86, 20, 27, 361), + Trans(86, 21, 27, 361), + Trans(86, 22, 27, 361), + Trans(86, 23, 27, 361), + Trans(86, 24, 27, 361), + Trans(86, 25, 27, 361), + Trans(86, 26, 27, 361), + Trans(86, 32, 27, 361), + Trans(86, 45, 27, 361), + Trans(86, 48, 27, 361), + Trans(86, 52, 27, 361), + Trans(87, 5, 27, 361), + Trans(87, 6, 27, 361), + Trans(87, 7, 27, 361), + Trans(87, 8, 27, 361), + Trans(87, 9, 27, 361), + Trans(87, 10, 27, 361), + Trans(87, 11, 27, 361), + Trans(87, 18, 27, 361), + Trans(87, 24, 27, 361), + Trans(87, 25, 27, 361), + Trans(87, 26, 27, 361), + Trans(87, 27, 27, 361), + Trans(87, 39, 27, 361), + Trans(87, 40, 27, 361), + Trans(87, 42, 27, 361), + Trans(87, 44, 27, 361), + Trans(87, 54, 27, 361), + Trans(87, 67, 27, 361), + Trans(87, 71, 27, 361), + Trans(87, 72, 27, 361), + Trans(87, 78, 27, 361), + Trans(87, 82, 27, 361), + Trans(87, 85, 27, 361), + Trans(87, 88, 27, 361), + Trans(87, 90, 27, 361), + Trans(87, 102, 27, 361), + Trans(87, 103, 27, 361), + Trans(87, 108, 27, 361), + Trans(87, 116, 27, 361), + Trans(87, 117, 27, 361), + Trans(88, 5, 27, 361), + Trans(88, 15, 27, 361), + Trans(88, 16, 27, 361), + Trans(88, 17, 27, 361), + Trans(88, 18, 27, 361), + Trans(88, 19, 27, 361), + Trans(88, 20, 27, 361), + Trans(88, 21, 27, 361), + Trans(88, 22, 27, 361), + Trans(88, 23, 27, 361), + Trans(88, 24, 27, 361), + Trans(88, 25, 27, 361), + Trans(88, 26, 27, 361), + Trans(88, 30, 27, 361), + Trans(88, 32, 27, 361), + Trans(88, 35, 27, 361), + Trans(88, 36, 27, 361), + Trans(88, 41, 27, 361), + Trans(88, 42, 27, 361), + Trans(88, 45, 27, 361), + Trans(88, 48, 27, 361), + Trans(88, 52, 27, 361), + Trans(89, 5, 27, 361), + Trans(89, 15, 27, 361), + Trans(89, 16, 27, 361), + Trans(89, 17, 27, 361), + Trans(89, 18, 27, 361), + Trans(89, 19, 27, 361), + Trans(89, 20, 27, 361), + Trans(89, 21, 27, 361), + Trans(89, 22, 27, 361), + Trans(89, 23, 27, 361), + Trans(89, 24, 27, 361), + Trans(89, 25, 27, 361), + Trans(89, 26, 27, 361), + Trans(89, 29, 27, 361), + Trans(89, 30, 27, 361), + Trans(89, 32, 27, 361), + Trans(89, 35, 27, 361), + Trans(89, 36, 27, 361), + Trans(89, 40, 27, 361), + Trans(89, 41, 27, 361), + Trans(89, 42, 27, 361), + Trans(89, 45, 27, 361), + Trans(89, 48, 27, 361), + Trans(89, 52, 27, 361), + Trans(90, 6, 27, 361), + Trans(90, 7, 27, 361), + Trans(90, 8, 27, 361), + Trans(90, 9, 27, 361), + Trans(90, 10, 27, 361), + Trans(90, 11, 27, 361), + Trans(90, 18, 27, 361), + Trans(90, 24, 27, 361), + Trans(90, 25, 27, 361), + Trans(90, 26, 27, 361), + Trans(90, 27, 27, 361), + Trans(90, 37, 27, 361), + Trans(90, 39, 27, 361), + Trans(90, 40, 27, 361), + Trans(90, 42, 27, 361), + Trans(90, 43, 27, 361), + Trans(90, 44, 27, 361), + Trans(90, 46, 27, 361), + Trans(90, 54, 27, 361), + Trans(90, 59, 27, 361), + Trans(90, 72, 27, 361), + Trans(90, 78, 27, 361), + Trans(90, 83, 27, 361), + Trans(90, 85, 27, 361), + Trans(90, 88, 27, 361), + Trans(90, 90, 27, 361), + Trans(90, 92, 27, 361), + Trans(90, 108, 27, 361), + Trans(90, 116, 27, 361), + Trans(90, 117, 27, 361), + Trans(91, 5, 27, 361), + Trans(91, 16, 27, 361), + Trans(91, 17, 27, 361), + Trans(91, 18, 27, 361), + Trans(91, 19, 27, 361), + Trans(91, 20, 27, 361), + Trans(91, 21, 27, 361), + Trans(91, 22, 27, 361), + Trans(91, 23, 27, 361), + Trans(91, 24, 27, 361), + Trans(91, 25, 27, 361), + Trans(91, 26, 27, 361), + Trans(91, 31, 27, 361), + Trans(91, 32, 27, 361), + Trans(91, 33, 27, 361), + Trans(91, 34, 27, 361), + Trans(91, 43, 27, 361), + Trans(91, 44, 27, 361), + Trans(91, 45, 27, 361), + Trans(91, 46, 27, 361), + Trans(91, 48, 27, 361), + Trans(91, 52, 27, 361), + Trans(91, 96, 27, 361), + Trans(92, 5, 27, 361), + Trans(92, 6, 27, 361), + Trans(92, 7, 27, 361), + Trans(92, 8, 27, 361), + Trans(92, 9, 27, 361), + Trans(92, 10, 27, 361), + Trans(92, 11, 27, 361), + Trans(92, 18, 27, 361), + Trans(92, 24, 27, 361), + Trans(92, 25, 27, 361), + Trans(92, 26, 27, 361), + Trans(92, 27, 27, 361), + Trans(92, 37, 27, 361), + Trans(92, 39, 27, 361), + Trans(92, 40, 27, 361), + Trans(92, 42, 27, 361), + Trans(92, 54, 27, 361), + Trans(92, 72, 27, 361), + Trans(92, 78, 27, 361), + Trans(92, 83, 27, 361), + Trans(92, 85, 27, 361), + Trans(92, 88, 27, 361), + Trans(92, 90, 27, 361), + Trans(92, 92, 27, 361), + Trans(92, 108, 27, 361), + Trans(92, 116, 27, 361), + Trans(92, 117, 27, 361), + Trans(93, 5, 27, 361), + Trans(93, 12, 27, 361), + Trans(93, 14, 27, 361), + Trans(93, 16, 27, 361), + Trans(93, 17, 27, 361), + Trans(93, 18, 27, 361), + Trans(93, 19, 27, 361), + Trans(93, 20, 27, 361), + Trans(93, 21, 27, 361), + Trans(93, 22, 27, 361), + Trans(93, 23, 27, 361), + Trans(93, 24, 27, 361), + Trans(93, 25, 27, 361), + Trans(93, 26, 27, 361), + Trans(93, 31, 27, 361), + Trans(93, 32, 27, 361), + Trans(93, 33, 27, 361), + Trans(93, 34, 27, 361), + Trans(93, 37, 27, 361), + Trans(93, 40, 27, 361), + Trans(93, 43, 27, 361), + Trans(93, 44, 27, 361), + Trans(93, 45, 27, 361), + Trans(93, 46, 27, 361), + Trans(93, 47, 27, 361), + Trans(93, 48, 27, 361), + Trans(93, 49, 27, 361), + Trans(93, 50, 27, 361), + Trans(93, 51, 27, 361), + Trans(93, 52, 27, 361), + Trans(93, 62, 27, 361), + Trans(93, 63, 27, 361), + Trans(93, 66, 27, 361), + Trans(93, 67, 27, 361), + Trans(93, 68, 27, 361), + Trans(93, 72, 27, 361), + Trans(93, 73, 27, 361), + Trans(93, 75, 27, 361), + Trans(93, 79, 27, 361), + Trans(93, 82, 27, 361), + Trans(93, 83, 27, 361), + Trans(93, 86, 27, 361), + Trans(93, 96, 27, 361), + Trans(93, 105, 27, 361), + Trans(93, 107, 27, 361), + Trans(93, 110, 27, 361), + Trans(93, 113, 27, 361), + Trans(93, 114, 27, 361), + Trans(93, 115, 27, 361), + Trans(94, 5, 27, 361), + Trans(94, 16, 27, 361), + Trans(94, 17, 27, 361), + Trans(94, 18, 27, 361), + Trans(94, 19, 27, 361), + Trans(94, 20, 27, 361), + Trans(94, 21, 27, 361), + Trans(94, 22, 27, 361), + Trans(94, 23, 27, 361), + Trans(94, 24, 27, 361), + Trans(94, 25, 27, 361), + Trans(94, 26, 27, 361), + Trans(94, 30, 27, 361), + Trans(94, 31, 27, 361), + Trans(94, 32, 27, 361), + Trans(94, 33, 27, 361), + Trans(94, 34, 27, 361), + Trans(94, 35, 27, 361), + Trans(94, 41, 27, 361), + Trans(94, 42, 27, 361), + Trans(94, 43, 27, 361), + Trans(94, 44, 27, 361), + Trans(94, 45, 27, 361), + Trans(94, 46, 27, 361), + Trans(94, 48, 27, 361), + Trans(94, 52, 27, 361), + Trans(94, 96, 27, 361), + Trans(95, 5, 27, 361), + Trans(95, 16, 27, 361), + Trans(95, 17, 27, 361), + Trans(95, 18, 27, 361), + Trans(95, 19, 27, 361), + Trans(95, 20, 27, 361), + Trans(95, 21, 27, 361), + Trans(95, 22, 27, 361), + Trans(95, 23, 27, 361), + Trans(95, 24, 27, 361), + Trans(95, 25, 27, 361), + Trans(95, 26, 27, 361), + Trans(95, 29, 27, 361), + Trans(95, 30, 27, 361), + Trans(95, 31, 27, 361), + Trans(95, 32, 27, 361), + Trans(95, 33, 27, 361), + Trans(95, 34, 27, 361), + Trans(95, 35, 27, 361), + Trans(95, 36, 27, 361), + Trans(95, 41, 27, 361), + Trans(95, 42, 27, 361), + Trans(95, 43, 27, 361), + Trans(95, 44, 27, 361), + Trans(95, 45, 27, 361), + Trans(95, 46, 27, 361), + Trans(95, 48, 27, 361), + Trans(95, 52, 27, 361), + Trans(95, 96, 27, 361), + Trans(96, 5, 27, 361), + Trans(96, 16, 27, 361), + Trans(96, 17, 27, 361), + Trans(96, 18, 27, 361), + Trans(96, 19, 27, 361), + Trans(96, 20, 27, 361), + Trans(96, 21, 27, 361), + Trans(96, 22, 27, 361), + Trans(96, 23, 27, 361), + Trans(96, 24, 27, 361), + Trans(96, 25, 27, 361), + Trans(96, 26, 27, 361), + Trans(96, 31, 27, 361), + Trans(96, 32, 27, 361), + Trans(96, 40, 27, 361), + Trans(96, 44, 27, 361), + Trans(96, 48, 27, 361), + Trans(96, 52, 27, 361), + Trans(96, 105, 27, 361), + Trans(97, 5, 27, 361), + Trans(97, 16, 27, 361), + Trans(97, 17, 27, 361), + Trans(97, 18, 27, 361), + Trans(97, 19, 27, 361), + Trans(97, 20, 27, 361), + Trans(97, 21, 27, 361), + Trans(97, 22, 27, 361), + Trans(97, 23, 27, 361), + Trans(97, 24, 27, 361), + Trans(97, 25, 27, 361), + Trans(97, 26, 27, 361), + Trans(97, 30, 27, 361), + Trans(97, 31, 27, 361), + Trans(97, 32, 27, 361), + Trans(97, 35, 27, 361), + Trans(97, 40, 27, 361), + Trans(97, 41, 27, 361), + Trans(97, 42, 27, 361), + Trans(97, 44, 27, 361), + Trans(97, 48, 27, 361), + Trans(97, 52, 27, 361), + Trans(97, 105, 27, 361), + Trans(98, 5, 27, 361), + Trans(98, 16, 27, 361), + Trans(98, 17, 27, 361), + Trans(98, 18, 27, 361), + Trans(98, 19, 27, 361), + Trans(98, 20, 27, 361), + Trans(98, 21, 27, 361), + Trans(98, 22, 27, 361), + Trans(98, 23, 27, 361), + Trans(98, 24, 27, 361), + Trans(98, 25, 27, 361), + Trans(98, 26, 27, 361), + Trans(98, 29, 27, 361), + Trans(98, 30, 27, 361), + Trans(98, 31, 27, 361), + Trans(98, 32, 27, 361), + Trans(98, 35, 27, 361), + Trans(98, 40, 27, 361), + Trans(98, 41, 27, 361), + Trans(98, 42, 27, 361), + Trans(98, 44, 27, 361), + Trans(98, 48, 27, 361), + Trans(98, 52, 27, 361), + Trans(98, 105, 27, 361), + Trans(99, 5, 27, 361), + Trans(99, 16, 27, 361), + Trans(99, 17, 27, 361), + Trans(99, 18, 27, 361), + Trans(99, 19, 27, 361), + Trans(99, 20, 27, 361), + Trans(99, 21, 27, 361), + Trans(99, 22, 27, 361), + Trans(99, 23, 27, 361), + Trans(99, 24, 27, 361), + Trans(99, 25, 27, 361), + Trans(99, 26, 27, 361), + Trans(99, 32, 27, 361), + Trans(99, 44, 27, 361), + Trans(99, 46, 27, 361), + Trans(99, 47, 27, 361), + Trans(99, 48, 27, 361), + Trans(99, 52, 27, 361), + Trans(100, 5, 27, 361), + Trans(100, 16, 27, 361), + Trans(100, 17, 27, 361), + Trans(100, 18, 27, 361), + Trans(100, 19, 27, 361), + Trans(100, 20, 27, 361), + Trans(100, 21, 27, 361), + Trans(100, 22, 27, 361), + Trans(100, 23, 27, 361), + Trans(100, 24, 27, 361), + Trans(100, 25, 27, 361), + Trans(100, 26, 27, 361), + Trans(100, 32, 27, 361), + Trans(100, 43, 27, 361), + Trans(100, 44, 27, 361), + Trans(100, 46, 27, 361), + Trans(100, 47, 27, 361), + Trans(100, 48, 27, 361), + Trans(100, 52, 27, 361), + Trans(101, 5, 27, 361), + Trans(101, 16, 27, 361), + Trans(101, 17, 27, 361), + Trans(101, 18, 27, 361), + Trans(101, 19, 27, 361), + Trans(101, 20, 27, 361), + Trans(101, 21, 27, 361), + Trans(101, 22, 27, 361), + Trans(101, 23, 27, 361), + Trans(101, 24, 27, 361), + Trans(101, 25, 27, 361), + Trans(101, 26, 27, 361), + Trans(101, 30, 27, 361), + Trans(101, 32, 27, 361), + Trans(101, 35, 27, 361), + Trans(101, 41, 27, 361), + Trans(101, 42, 27, 361), + Trans(101, 43, 27, 361), + Trans(101, 44, 27, 361), + Trans(101, 46, 27, 361), + Trans(101, 47, 27, 361), + Trans(101, 48, 27, 361), + Trans(101, 52, 27, 361), + Trans(102, 5, 27, 361), + Trans(102, 16, 27, 361), + Trans(102, 17, 27, 361), + Trans(102, 18, 27, 361), + Trans(102, 19, 27, 361), + Trans(102, 20, 27, 361), + Trans(102, 21, 27, 361), + Trans(102, 22, 27, 361), + Trans(102, 23, 27, 361), + Trans(102, 24, 27, 361), + Trans(102, 25, 27, 361), + Trans(102, 26, 27, 361), + Trans(102, 29, 27, 361), + Trans(102, 30, 27, 361), + Trans(102, 32, 27, 361), + Trans(102, 35, 27, 361), + Trans(102, 41, 27, 361), + Trans(102, 42, 27, 361), + Trans(102, 43, 27, 361), + Trans(102, 44, 27, 361), + Trans(102, 46, 27, 361), + Trans(102, 47, 27, 361), + Trans(102, 48, 27, 361), + Trans(102, 52, 27, 361), + Trans(103, 5, 27, 361), + Trans(103, 16, 27, 361), + Trans(103, 17, 27, 361), + Trans(103, 18, 27, 361), + Trans(103, 19, 27, 361), + Trans(103, 20, 27, 361), + Trans(103, 21, 27, 361), + Trans(103, 22, 27, 361), + Trans(103, 23, 27, 361), + Trans(103, 24, 27, 361), + Trans(103, 25, 27, 361), + Trans(103, 26, 27, 361), + Trans(103, 32, 27, 361), + Trans(103, 43, 27, 361), + Trans(103, 48, 27, 361), + Trans(103, 52, 27, 361), + Trans(104, 5, 27, 361), + Trans(104, 16, 27, 361), + Trans(104, 17, 27, 361), + Trans(104, 18, 27, 361), + Trans(104, 19, 27, 361), + Trans(104, 20, 27, 361), + Trans(104, 21, 27, 361), + Trans(104, 22, 27, 361), + Trans(104, 23, 27, 361), + Trans(104, 24, 27, 361), + Trans(104, 25, 27, 361), + Trans(104, 26, 27, 361), + Trans(104, 30, 27, 361), + Trans(104, 32, 27, 361), + Trans(104, 35, 27, 361), + Trans(104, 41, 27, 361), + Trans(104, 42, 27, 361), + Trans(104, 43, 27, 361), + Trans(104, 48, 27, 361), + Trans(104, 52, 27, 361), + Trans(105, 5, 27, 361), + Trans(105, 16, 27, 361), + Trans(105, 17, 27, 361), + Trans(105, 18, 27, 361), + Trans(105, 19, 27, 361), + Trans(105, 20, 27, 361), + Trans(105, 21, 27, 361), + Trans(105, 22, 27, 361), + Trans(105, 23, 27, 361), + Trans(105, 24, 27, 361), + Trans(105, 25, 27, 361), + Trans(105, 26, 27, 361), + Trans(105, 29, 27, 361), + Trans(105, 30, 27, 361), + Trans(105, 32, 27, 361), + Trans(105, 35, 27, 361), + Trans(105, 41, 27, 361), + Trans(105, 42, 27, 361), + Trans(105, 43, 27, 361), + Trans(105, 48, 27, 361), + Trans(105, 52, 27, 361), + Trans(106, 5, 27, 361), + Trans(106, 12, 27, 361), + Trans(106, 14, 27, 361), + Trans(106, 16, 27, 361), + Trans(106, 17, 27, 361), + Trans(106, 18, 27, 361), + Trans(106, 19, 27, 361), + Trans(106, 20, 27, 361), + Trans(106, 21, 27, 361), + Trans(106, 22, 27, 361), + Trans(106, 23, 27, 361), + Trans(106, 24, 27, 361), + Trans(106, 25, 27, 361), + Trans(106, 26, 27, 361), + Trans(106, 31, 27, 361), + Trans(106, 32, 27, 361), + Trans(106, 45, 27, 361), + Trans(106, 48, 27, 361), + Trans(106, 52, 27, 361), + Trans(106, 105, 27, 361), + Trans(107, 5, 27, 361), + Trans(107, 12, 27, 361), + Trans(107, 14, 27, 361), + Trans(107, 16, 27, 361), + Trans(107, 17, 27, 361), + Trans(107, 18, 27, 361), + Trans(107, 19, 27, 361), + Trans(107, 20, 27, 361), + Trans(107, 21, 27, 361), + Trans(107, 22, 27, 361), + Trans(107, 23, 27, 361), + Trans(107, 24, 27, 361), + Trans(107, 25, 27, 361), + Trans(107, 26, 27, 361), + Trans(107, 30, 27, 361), + Trans(107, 31, 27, 361), + Trans(107, 32, 27, 361), + Trans(107, 35, 27, 361), + Trans(107, 41, 27, 361), + Trans(107, 42, 27, 361), + Trans(107, 45, 27, 361), + Trans(107, 48, 27, 361), + Trans(107, 52, 27, 361), + Trans(107, 105, 27, 361), + Trans(108, 5, 27, 361), + Trans(108, 12, 27, 361), + Trans(108, 14, 27, 361), + Trans(108, 16, 27, 361), + Trans(108, 17, 27, 361), + Trans(108, 18, 27, 361), + Trans(108, 19, 27, 361), + Trans(108, 20, 27, 361), + Trans(108, 21, 27, 361), + Trans(108, 22, 27, 361), + Trans(108, 23, 27, 361), + Trans(108, 24, 27, 361), + Trans(108, 25, 27, 361), + Trans(108, 26, 27, 361), + Trans(108, 29, 27, 361), + Trans(108, 30, 27, 361), + Trans(108, 31, 27, 361), + Trans(108, 32, 27, 361), + Trans(108, 35, 27, 361), + Trans(108, 41, 27, 361), + Trans(108, 42, 27, 361), + Trans(108, 45, 27, 361), + Trans(108, 48, 27, 361), + Trans(108, 52, 27, 361), + Trans(108, 105, 27, 361), + Trans(109, 6, 27, 361), + Trans(109, 7, 27, 361), + Trans(109, 8, 27, 361), + Trans(109, 9, 27, 361), + Trans(109, 10, 27, 361), + Trans(109, 11, 27, 361), + Trans(109, 18, 27, 361), + Trans(109, 24, 27, 361), + Trans(109, 25, 27, 361), + Trans(109, 26, 27, 361), + Trans(109, 27, 27, 361), + Trans(109, 37, 27, 361), + Trans(109, 39, 27, 361), + Trans(109, 40, 27, 361), + Trans(109, 42, 27, 361), + Trans(109, 46, 27, 361), + Trans(109, 54, 27, 361), + Trans(109, 72, 27, 361), + Trans(109, 78, 27, 361), + Trans(109, 85, 27, 361), + Trans(109, 88, 27, 361), + Trans(109, 90, 27, 361), + Trans(109, 108, 27, 361), + Trans(109, 116, 27, 361), + Trans(109, 117, 27, 361), + Trans(110, 5, 27, 361), + Trans(110, 16, 27, 361), + Trans(110, 17, 27, 361), + Trans(110, 18, 27, 361), + Trans(110, 19, 27, 361), + Trans(110, 20, 27, 361), + Trans(110, 21, 27, 361), + Trans(110, 22, 27, 361), + Trans(110, 23, 27, 361), + Trans(110, 24, 27, 361), + Trans(110, 25, 27, 361), + Trans(110, 26, 27, 361), + Trans(110, 32, 27, 361), + Trans(110, 46, 27, 361), + Trans(110, 48, 27, 361), + Trans(110, 52, 27, 361), + Trans(111, 5, 27, 361), + Trans(111, 6, 27, 361), + Trans(111, 7, 27, 361), + Trans(111, 8, 27, 361), + Trans(111, 9, 27, 361), + Trans(111, 10, 27, 361), + Trans(111, 11, 27, 361), + Trans(111, 18, 27, 361), + Trans(111, 24, 27, 361), + Trans(111, 25, 27, 361), + Trans(111, 26, 27, 361), + Trans(111, 27, 27, 361), + Trans(111, 37, 27, 361), + Trans(111, 39, 27, 361), + Trans(111, 40, 27, 361), + Trans(111, 42, 27, 361), + Trans(111, 54, 27, 361), + Trans(111, 72, 27, 361), + Trans(111, 78, 27, 361), + Trans(111, 85, 27, 361), + Trans(111, 88, 27, 361), + Trans(111, 90, 27, 361), + Trans(111, 108, 27, 361), + Trans(111, 116, 27, 361), + Trans(111, 117, 27, 361), + Trans(112, 5, 27, 361), + Trans(112, 16, 27, 361), + Trans(112, 17, 27, 361), + Trans(112, 18, 27, 361), + Trans(112, 19, 27, 361), + Trans(112, 20, 27, 361), + Trans(112, 21, 27, 361), + Trans(112, 22, 27, 361), + Trans(112, 23, 27, 361), + Trans(112, 24, 27, 361), + Trans(112, 25, 27, 361), + Trans(112, 26, 27, 361), + Trans(112, 30, 27, 361), + Trans(112, 32, 27, 361), + Trans(112, 35, 27, 361), + Trans(112, 41, 27, 361), + Trans(112, 42, 27, 361), + Trans(112, 46, 27, 361), + Trans(112, 48, 27, 361), + Trans(112, 52, 27, 361), + Trans(113, 5, 27, 361), + Trans(113, 16, 27, 361), + Trans(113, 17, 27, 361), + Trans(113, 18, 27, 361), + Trans(113, 19, 27, 361), + Trans(113, 20, 27, 361), + Trans(113, 21, 27, 361), + Trans(113, 22, 27, 361), + Trans(113, 23, 27, 361), + Trans(113, 24, 27, 361), + Trans(113, 25, 27, 361), + Trans(113, 26, 27, 361), + Trans(113, 29, 27, 361), + Trans(113, 30, 27, 361), + Trans(113, 31, 27, 361), + Trans(113, 32, 27, 361), + Trans(113, 35, 27, 361), + Trans(113, 41, 27, 361), + Trans(113, 42, 27, 361), + Trans(113, 46, 27, 361), + Trans(113, 48, 27, 361), + Trans(113, 52, 27, 361), + Trans(114, 5, 27, 361), + Trans(114, 16, 27, 361), + Trans(114, 17, 27, 361), + Trans(114, 18, 27, 361), + Trans(114, 19, 27, 361), + Trans(114, 20, 27, 361), + Trans(114, 21, 27, 361), + Trans(114, 22, 27, 361), + Trans(114, 23, 27, 361), + Trans(114, 24, 27, 361), + Trans(114, 25, 27, 361), + Trans(114, 26, 27, 361), + Trans(114, 33, 27, 361), + Trans(114, 34, 27, 361), + Trans(114, 40, 27, 361), + Trans(114, 48, 27, 361), + Trans(114, 52, 27, 361), + Trans(114, 105, 27, 361), + Trans(115, 5, 27, 361), + Trans(115, 16, 27, 361), + Trans(115, 17, 27, 361), + Trans(115, 18, 27, 361), + Trans(115, 19, 27, 361), + Trans(115, 20, 27, 361), + Trans(115, 21, 27, 361), + Trans(115, 22, 27, 361), + Trans(115, 23, 27, 361), + Trans(115, 24, 27, 361), + Trans(115, 25, 27, 361), + Trans(115, 26, 27, 361), + Trans(115, 30, 27, 361), + Trans(115, 33, 27, 361), + Trans(115, 34, 27, 361), + Trans(115, 35, 27, 361), + Trans(115, 40, 27, 361), + Trans(115, 41, 27, 361), + Trans(115, 42, 27, 361), + Trans(115, 48, 27, 361), + Trans(115, 52, 27, 361), + Trans(115, 105, 27, 361), + Trans(116, 5, 27, 361), + Trans(116, 16, 27, 361), + Trans(116, 17, 27, 361), + Trans(116, 18, 27, 361), + Trans(116, 19, 27, 361), + Trans(116, 20, 27, 361), + Trans(116, 21, 27, 361), + Trans(116, 22, 27, 361), + Trans(116, 23, 27, 361), + Trans(116, 24, 27, 361), + Trans(116, 25, 27, 361), + Trans(116, 26, 27, 361), + Trans(116, 29, 27, 361), + Trans(116, 30, 27, 361), + Trans(116, 33, 27, 361), + Trans(116, 34, 27, 361), + Trans(116, 35, 27, 361), + Trans(116, 40, 27, 361), + Trans(116, 41, 27, 361), + Trans(116, 42, 27, 361), + Trans(116, 48, 27, 361), + Trans(116, 52, 27, 361), + Trans(116, 105, 27, 361), + Trans(117, 5, 27, 361), + Trans(117, 16, 27, 361), + Trans(117, 17, 27, 361), + Trans(117, 18, 27, 361), + Trans(117, 19, 27, 361), + Trans(117, 20, 27, 361), + Trans(117, 21, 27, 361), + Trans(117, 22, 27, 361), + Trans(117, 23, 27, 361), + Trans(117, 24, 27, 361), + Trans(117, 25, 27, 361), + Trans(117, 26, 27, 361), + Trans(117, 32, 27, 361), + Trans(117, 44, 27, 361), + Trans(117, 48, 27, 361), + Trans(117, 52, 27, 361), + Trans(118, 5, 27, 361), + Trans(118, 16, 27, 361), + Trans(118, 17, 27, 361), + Trans(118, 18, 27, 361), + Trans(118, 19, 27, 361), + Trans(118, 20, 27, 361), + Trans(118, 21, 27, 361), + Trans(118, 22, 27, 361), + Trans(118, 23, 27, 361), + Trans(118, 24, 27, 361), + Trans(118, 25, 27, 361), + Trans(118, 26, 27, 361), + Trans(118, 30, 27, 361), + Trans(118, 32, 27, 361), + Trans(118, 35, 27, 361), + Trans(118, 41, 27, 361), + Trans(118, 42, 27, 361), + Trans(118, 44, 27, 361), + Trans(118, 48, 27, 361), + Trans(118, 52, 27, 361), + Trans(119, 5, 27, 361), + Trans(119, 16, 27, 361), + Trans(119, 17, 27, 361), + Trans(119, 18, 27, 361), + Trans(119, 19, 27, 361), + Trans(119, 20, 27, 361), + Trans(119, 21, 27, 361), + Trans(119, 22, 27, 361), + Trans(119, 23, 27, 361), + Trans(119, 24, 27, 361), + Trans(119, 25, 27, 361), + Trans(119, 26, 27, 361), + Trans(119, 29, 27, 361), + Trans(119, 30, 27, 361), + Trans(119, 32, 27, 361), + Trans(119, 35, 27, 361), + Trans(119, 41, 27, 361), + Trans(119, 42, 27, 361), + Trans(119, 44, 27, 361), + Trans(119, 48, 27, 361), + Trans(119, 52, 27, 361), + Trans(120, 6, 27, 361), + Trans(120, 7, 27, 361), + Trans(120, 8, 27, 361), + Trans(120, 9, 27, 361), + Trans(120, 10, 27, 361), + Trans(120, 11, 27, 361), + Trans(120, 15, 27, 361), + Trans(120, 18, 27, 361), + Trans(120, 24, 27, 361), + Trans(120, 25, 27, 361), + Trans(120, 26, 27, 361), + Trans(120, 27, 27, 361), + Trans(120, 39, 27, 361), + Trans(120, 40, 27, 361), + Trans(120, 42, 27, 361), + Trans(120, 54, 27, 361), + Trans(120, 72, 27, 361), + Trans(120, 78, 27, 361), + Trans(120, 85, 27, 361), + Trans(120, 88, 27, 361), + Trans(120, 90, 27, 361), + Trans(120, 108, 27, 361), + Trans(120, 116, 27, 361), + Trans(120, 117, 27, 361), + Trans(121, 12, 27, 361), + Trans(121, 14, 27, 361), + Trans(121, 15, 27, 361), + Trans(121, 16, 27, 361), + Trans(121, 17, 27, 361), + Trans(121, 18, 27, 361), + Trans(121, 19, 27, 361), + Trans(121, 20, 27, 361), + Trans(121, 21, 27, 361), + Trans(121, 22, 27, 361), + Trans(121, 23, 27, 361), + Trans(121, 24, 27, 361), + Trans(121, 25, 27, 361), + Trans(121, 26, 27, 361), + Trans(121, 31, 27, 361), + Trans(121, 32, 27, 361), + Trans(121, 33, 27, 361), + Trans(121, 34, 27, 361), + Trans(121, 35, 27, 361), + Trans(121, 36, 27, 361), + Trans(121, 37, 27, 361), + Trans(121, 40, 27, 361), + Trans(121, 41, 27, 361), + Trans(121, 42, 27, 361), + Trans(121, 43, 27, 361), + Trans(121, 44, 27, 361), + Trans(121, 45, 27, 361), + Trans(121, 46, 27, 361), + Trans(121, 47, 27, 361), + Trans(121, 48, 27, 361), + Trans(121, 52, 27, 361), + Trans(121, 96, 27, 361), + Trans(121, 105, 27, 361), + Trans(122, 42, 27, 361), + Trans(123, 5, 27, 361), + Trans(123, 37, 27, 361), + Trans(123, 40, 27, 361), + Trans(123, 46, 27, 361), + Trans(123, 83, 27, 361), + Trans(123, 92, 27, 361), + Trans(123, 117, 27, 361), + Trans(124, 55, 27, 361), + Trans(124, 56, 27, 361), + Trans(124, 57, 27, 361), + Trans(124, 64, 27, 361), + Trans(124, 65, 27, 361), + Trans(124, 69, 27, 361), + Trans(124, 70, 27, 361), + Trans(124, 97, 27, 361), + Trans(124, 98, 27, 361), + Trans(124, 99, 27, 361), + Trans(124, 100, 27, 361), + Trans(124, 101, 27, 361), + Trans(124, 111, 27, 361), + Trans(124, 112, 27, 361), + Trans(124, 116, 27, 361), + Trans(124, 117, 27, 361), + Trans(125, 5, 27, 361), + Trans(125, 12, 27, 361), + Trans(125, 14, 27, 361), + Trans(125, 16, 27, 361), + Trans(125, 17, 27, 361), + Trans(125, 18, 27, 361), + Trans(125, 19, 27, 361), + Trans(125, 20, 27, 361), + Trans(125, 21, 27, 361), + Trans(125, 22, 27, 361), + Trans(125, 23, 27, 361), + Trans(125, 24, 27, 361), + Trans(125, 25, 27, 361), + Trans(125, 26, 27, 361), + Trans(125, 31, 27, 361), + Trans(125, 32, 27, 361), + Trans(125, 33, 27, 361), + Trans(125, 34, 27, 361), + Trans(125, 40, 27, 361), + Trans(125, 43, 27, 361), + Trans(125, 44, 27, 361), + Trans(125, 45, 27, 361), + Trans(125, 46, 27, 361), + Trans(125, 47, 27, 361), + Trans(125, 48, 27, 361), + Trans(125, 96, 27, 361), + Trans(125, 105, 27, 361), + Trans(126, 5, 27, 361), + Trans(126, 12, 27, 361), + Trans(126, 14, 27, 361), + Trans(126, 16, 27, 361), + Trans(126, 17, 27, 361), + Trans(126, 18, 27, 361), + Trans(126, 19, 27, 361), + Trans(126, 20, 27, 361), + Trans(126, 21, 27, 361), + Trans(126, 22, 27, 361), + Trans(126, 23, 27, 361), + Trans(126, 24, 27, 361), + Trans(126, 25, 27, 361), + Trans(126, 26, 27, 361), + Trans(126, 30, 27, 361), + Trans(126, 31, 27, 361), + Trans(126, 32, 27, 361), + Trans(126, 33, 27, 361), + Trans(126, 34, 27, 361), + Trans(126, 40, 27, 361), + Trans(126, 43, 27, 361), + Trans(126, 44, 27, 361), + Trans(126, 45, 27, 361), + Trans(126, 46, 27, 361), + Trans(126, 47, 27, 361), + Trans(126, 48, 27, 361), + Trans(126, 96, 27, 361), + Trans(126, 105, 27, 361), + Trans(127, 5, 27, 361), + Trans(127, 12, 27, 361), + Trans(127, 14, 27, 361), + Trans(127, 16, 27, 361), + Trans(127, 17, 27, 361), + Trans(127, 18, 27, 361), + Trans(127, 19, 27, 361), + Trans(127, 20, 27, 361), + Trans(127, 21, 27, 361), + Trans(127, 22, 27, 361), + Trans(127, 23, 27, 361), + Trans(127, 24, 27, 361), + Trans(127, 25, 27, 361), + Trans(127, 26, 27, 361), + Trans(127, 29, 27, 361), + Trans(127, 30, 27, 361), + Trans(127, 31, 27, 361), + Trans(127, 32, 27, 361), + Trans(127, 33, 27, 361), + Trans(127, 34, 27, 361), + Trans(127, 40, 27, 361), + Trans(127, 43, 27, 361), + Trans(127, 44, 27, 361), + Trans(127, 45, 27, 361), + Trans(127, 46, 27, 361), + Trans(127, 47, 27, 361), + Trans(127, 48, 27, 361), + Trans(127, 96, 27, 361), + Trans(127, 105, 27, 361), + Trans(128, 117, 27, 361), + Trans(129, 5, 27, 361), + Trans(129, 12, 27, 361), + Trans(129, 14, 27, 361), + Trans(129, 15, 27, 361), + Trans(129, 16, 27, 361), + Trans(129, 17, 27, 361), + Trans(129, 18, 27, 361), + Trans(129, 19, 27, 361), + Trans(129, 20, 27, 361), + Trans(129, 21, 27, 361), + Trans(129, 22, 27, 361), + Trans(129, 23, 27, 361), + Trans(129, 24, 27, 361), + Trans(129, 25, 27, 361), + Trans(129, 26, 27, 361), + Trans(129, 31, 27, 361), + Trans(129, 32, 27, 361), + Trans(129, 33, 27, 361), + Trans(129, 34, 27, 361), + Trans(129, 35, 27, 361), + Trans(129, 36, 27, 361), + Trans(129, 40, 27, 361), + Trans(129, 41, 27, 361), + Trans(129, 42, 27, 361), + Trans(129, 43, 27, 361), + Trans(129, 44, 27, 361), + Trans(129, 45, 27, 361), + Trans(129, 46, 27, 361), + Trans(129, 47, 27, 361), + Trans(129, 48, 27, 361), + Trans(129, 52, 27, 361), + Trans(129, 96, 27, 361), + Trans(129, 105, 27, 361), ], k: 3, }, - /* 557 - "ScopedIdentifierOpt" */ + /* 570 - "ScopedIdentifierOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 359), - Trans(0, 14, 2, 359), - Trans(0, 15, 2, 359), - Trans(0, 16, 2, 359), - Trans(0, 17, 2, 359), - Trans(0, 18, 2, 359), - Trans(0, 19, 2, 359), - Trans(0, 20, 2, 359), - Trans(0, 21, 2, 359), - Trans(0, 22, 2, 359), - Trans(0, 23, 2, 359), - Trans(0, 24, 2, 359), - Trans(0, 25, 2, 359), - Trans(0, 26, 2, 359), - Trans(0, 29, 1, 358), - Trans(0, 30, 2, 359), - Trans(0, 31, 2, 359), - Trans(0, 32, 2, 359), - Trans(0, 33, 2, 359), - Trans(0, 34, 2, 359), - Trans(0, 35, 2, 359), - Trans(0, 36, 2, 359), - Trans(0, 37, 2, 359), - Trans(0, 38, 2, 359), - Trans(0, 40, 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, 46, 2, 359), - Trans(0, 47, 2, 359), - Trans(0, 48, 2, 359), - Trans(0, 52, 2, 359), - Trans(0, 80, 2, 359), - Trans(0, 94, 2, 359), - Trans(0, 103, 2, 359), + Trans(0, 12, 2, 365), + Trans(0, 14, 2, 365), + Trans(0, 15, 2, 365), + Trans(0, 16, 2, 365), + Trans(0, 17, 2, 365), + Trans(0, 18, 2, 365), + Trans(0, 19, 2, 365), + Trans(0, 20, 2, 365), + Trans(0, 21, 2, 365), + Trans(0, 22, 2, 365), + Trans(0, 23, 2, 365), + Trans(0, 24, 2, 365), + Trans(0, 25, 2, 365), + Trans(0, 26, 2, 365), + Trans(0, 29, 1, 364), + Trans(0, 30, 2, 365), + Trans(0, 31, 2, 365), + Trans(0, 32, 2, 365), + Trans(0, 33, 2, 365), + Trans(0, 34, 2, 365), + Trans(0, 35, 2, 365), + Trans(0, 36, 2, 365), + Trans(0, 37, 2, 365), + Trans(0, 38, 2, 365), + Trans(0, 40, 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, 46, 2, 365), + Trans(0, 47, 2, 365), + Trans(0, 48, 2, 365), + Trans(0, 52, 2, 365), + Trans(0, 81, 2, 365), + Trans(0, 96, 2, 365), + Trans(0, 105, 2, 365), ], k: 1, }, - /* 558 - "ScopedIdentifierOpt0" */ + /* 571 - "ScopedIdentifierOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - 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, 29, 1, 356), - 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, 36, 2, 357), - Trans(0, 37, 2, 357), - Trans(0, 38, 2, 357), - Trans(0, 40, 2, 357), - 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, 48, 2, 357), - Trans(0, 52, 2, 357), - Trans(0, 80, 2, 357), - Trans(0, 94, 2, 357), - Trans(0, 103, 2, 357), + Trans(0, 12, 2, 363), + Trans(0, 14, 2, 363), + Trans(0, 15, 2, 363), + Trans(0, 16, 2, 363), + Trans(0, 17, 2, 363), + Trans(0, 18, 2, 363), + Trans(0, 19, 2, 363), + Trans(0, 20, 2, 363), + Trans(0, 21, 2, 363), + Trans(0, 22, 2, 363), + Trans(0, 23, 2, 363), + Trans(0, 24, 2, 363), + Trans(0, 25, 2, 363), + Trans(0, 26, 2, 363), + Trans(0, 29, 1, 362), + Trans(0, 30, 2, 363), + Trans(0, 31, 2, 363), + Trans(0, 32, 2, 363), + Trans(0, 33, 2, 363), + Trans(0, 34, 2, 363), + Trans(0, 35, 2, 363), + Trans(0, 36, 2, 363), + Trans(0, 37, 2, 363), + Trans(0, 38, 2, 363), + Trans(0, 40, 2, 363), + Trans(0, 41, 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, 47, 2, 363), + Trans(0, 48, 2, 363), + Trans(0, 52, 2, 363), + Trans(0, 81, 2, 363), + Trans(0, 96, 2, 363), + Trans(0, 105, 2, 363), ], k: 1, }, - /* 559 - "Select" */ + /* 572 - "Select" */ LookaheadDFA { - prod0: 479, + prod0: 485, transitions: &[], k: 0, }, - /* 560 - "SelectOperator" */ + /* 573 - "SelectOperator" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 3, 484), - Trans(0, 14, 2, 483), - Trans(0, 31, 1, 482), - Trans(0, 103, 4, 485), + Trans(0, 12, 3, 490), + Trans(0, 14, 2, 489), + Trans(0, 31, 1, 488), + Trans(0, 105, 4, 491), ], k: 1, }, - /* 561 - "SelectOpt" */ + /* 574 - "SelectOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 1, 480), - Trans(0, 14, 1, 480), - Trans(0, 31, 1, 480), - Trans(0, 45, 2, 481), - Trans(0, 103, 1, 480), + Trans(0, 12, 1, 486), + Trans(0, 14, 1, 486), + Trans(0, 31, 1, 486), + Trans(0, 45, 2, 487), + Trans(0, 105, 1, 486), ], k: 1, }, - /* 562 - "Semicolon" */ + /* 575 - "Semicolon" */ LookaheadDFA { - prod0: 268, + prod0: 272, transitions: &[], k: 0, }, - /* 563 - "SemicolonTerm" */ + /* 576 - "SemicolonTerm" */ LookaheadDFA { prod0: 42, transitions: &[], k: 0, }, - /* 564 - "SemicolonToken" */ + /* 577 - "SemicolonToken" */ LookaheadDFA { - prod0: 157, + prod0: 159, transitions: &[], k: 0, }, - /* 565 - "Signed" */ + /* 578 - "Signed" */ LookaheadDFA { - prod0: 323, + prod0: 329, transitions: &[], k: 0, }, - /* 566 - "SignedTerm" */ + /* 579 - "SignedTerm" */ LookaheadDFA { - prod0: 97, + prod0: 99, transitions: &[], k: 0, }, - /* 567 - "SignedToken" */ + /* 580 - "SignedToken" */ LookaheadDFA { - prod0: 212, + prod0: 216, transitions: &[], k: 0, }, - /* 568 - "Star" */ + /* 581 - "Star" */ LookaheadDFA { - prod0: 269, + prod0: 273, transitions: &[], k: 0, }, - /* 569 - "StarTerm" */ + /* 582 - "StarTerm" */ LookaheadDFA { prod0: 43, transitions: &[], k: 0, }, - /* 570 - "StarToken" */ + /* 583 - "StarToken" */ LookaheadDFA { - prod0: 158, + prod0: 160, transitions: &[], k: 0, }, - /* 571 - "Start" */ + /* 584 - "Start" */ LookaheadDFA { - prod0: 226, + prod0: 230, transitions: &[], k: 0, }, - /* 572 - "StartToken" */ + /* 585 - "StartToken" */ LookaheadDFA { - prod0: 115, + prod0: 117, transitions: &[], k: 0, }, - /* 573 - "Statement" */ + /* 586 - "Statement" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 54, 8, 551), - Trans(0, 66, 7, 550), - Trans(0, 70, 4, 547), - Trans(0, 71, 3, 546), - Trans(0, 81, 1, 544), - Trans(0, 100, 5, 548), - Trans(0, 101, 6, 549), - Trans(0, 106, 9, 552), - Trans(0, 114, 2, 545), - Trans(0, 115, 2, 545), + Trans(0, 54, 8, 556), + Trans(0, 67, 7, 555), + Trans(0, 71, 4, 552), + Trans(0, 72, 3, 551), + Trans(0, 82, 1, 549), + Trans(0, 102, 5, 553), + Trans(0, 103, 6, 554), + Trans(0, 108, 9, 557), + Trans(0, 116, 2, 550), + Trans(0, 117, 2, 550), ], k: 1, }, - /* 574 - "Step" */ + /* 587 - "Step" */ LookaheadDFA { - prod0: 324, + prod0: 330, transitions: &[], k: 0, }, - /* 575 - "StepTerm" */ + /* 588 - "StepTerm" */ LookaheadDFA { - prod0: 98, + prod0: 100, transitions: &[], k: 0, }, - /* 576 - "StepToken" */ + /* 589 - "StepToken" */ LookaheadDFA { - prod0: 213, + prod0: 217, transitions: &[], k: 0, }, - /* 577 - "Strin" */ + /* 590 - "Strin" */ LookaheadDFA { - prod0: 325, + prod0: 331, transitions: &[], k: 0, }, - /* 578 - "StringLiteral" */ + /* 591 - "StringLiteral" */ LookaheadDFA { - prod0: 227, + prod0: 231, transitions: &[], k: 0, }, - /* 579 - "StringLiteralTerm" */ + /* 592 - "StringLiteralTerm" */ LookaheadDFA { prod0: 1, transitions: &[], k: 0, }, - /* 580 - "StringLiteralToken" */ + /* 593 - "StringLiteralToken" */ LookaheadDFA { - prod0: 116, + prod0: 118, transitions: &[], k: 0, }, - /* 581 - "StringTerm" */ + /* 594 - "StringTerm" */ LookaheadDFA { - prod0: 99, + prod0: 101, transitions: &[], k: 0, }, - /* 582 - "StringToken" */ + /* 595 - "StringToken" */ LookaheadDFA { - prod0: 214, + prod0: 218, transitions: &[], k: 0, }, - /* 583 - "Struct" */ + /* 596 - "Struct" */ LookaheadDFA { - prod0: 326, + prod0: 332, transitions: &[], k: 0, }, - /* 584 - "StructTerm" */ + /* 597 - "StructTerm" */ LookaheadDFA { - prod0: 100, + prod0: 102, transitions: &[], k: 0, }, - /* 585 - "StructToken" */ + /* 598 - "StructToken" */ LookaheadDFA { - prod0: 215, + prod0: 219, transitions: &[], k: 0, }, - /* 586 - "StructUnion" */ + /* 599 - "StructUnion" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 105, 1, 679), Trans(0, 111, 2, 680)], + transitions: &[Trans(0, 107, 1, 684), Trans(0, 113, 2, 685)], k: 1, }, - /* 587 - "StructUnionDeclaration" */ + /* 600 - "StructUnionDeclaration" */ LookaheadDFA { - prod0: 681, + prod0: 686, transitions: &[], k: 0, }, - /* 588 - "StructUnionDeclarationOpt" */ + /* 601 - "StructUnionDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 1, 682), Trans(0, 40, 2, 683)], + transitions: &[Trans(0, 29, 1, 687), Trans(0, 40, 2, 688)], k: 1, }, - /* 589 - "StructUnionGroup" */ + /* 602 - "StructUnionGroup" */ LookaheadDFA { - prod0: 689, + prod0: 694, transitions: &[], k: 0, }, - /* 590 - "StructUnionGroupGroup" */ + /* 603 - "StructUnionGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 690), Trans(0, 115, 2, 691)], + transitions: &[Trans(0, 40, 1, 695), Trans(0, 117, 2, 696)], k: 1, }, - /* 591 - "StructUnionGroupList" */ + /* 604 - "StructUnionGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 692), - Trans(0, 40, 2, 693), - Trans(0, 115, 2, 693), + Trans(0, 37, 1, 697), + Trans(0, 40, 2, 698), + Trans(0, 117, 2, 698), ], k: 1, }, - /* 592 - "StructUnionItem" */ + /* 605 - "StructUnionItem" */ LookaheadDFA { - prod0: 694, + prod0: 699, transitions: &[], k: 0, }, - /* 593 - "StructUnionList" */ + /* 606 - "StructUnionList" */ LookaheadDFA { - prod0: 684, + prod0: 689, transitions: &[], k: 0, }, - /* 594 - "StructUnionListList" */ + /* 607 - "StructUnionListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -16016,19 +16178,19 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 37, 2, -1), Trans(1, 40, 4, -1), Trans(1, 44, 21, -1), - Trans(1, 115, 5, -1), - Trans(2, 5, 3, 685), - Trans(2, 41, 3, 685), - Trans(4, 5, 3, 685), - Trans(4, 37, 3, 685), - Trans(4, 40, 3, 685), - Trans(4, 115, 3, 685), - Trans(5, 5, 3, 685), - Trans(5, 31, 3, 685), - Trans(6, 37, 3, 685), - Trans(6, 40, 3, 685), - Trans(6, 44, 20, 686), - Trans(6, 115, 3, 685), + Trans(1, 117, 5, -1), + Trans(2, 5, 3, 690), + Trans(2, 41, 3, 690), + Trans(4, 5, 3, 690), + Trans(4, 37, 3, 690), + Trans(4, 40, 3, 690), + Trans(4, 117, 3, 690), + Trans(5, 5, 3, 690), + Trans(5, 31, 3, 690), + Trans(6, 37, 3, 690), + Trans(6, 40, 3, 690), + Trans(6, 44, 20, 691), + Trans(6, 117, 3, 690), Trans(7, 5, 8, -1), Trans(7, 31, 9, -1), Trans(7, 32, 10, -1), @@ -16038,731 +16200,711 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(7, 49, 14, -1), Trans(7, 50, 15, -1), Trans(7, 51, 9, -1), - Trans(7, 61, 9, -1), - Trans(7, 62, 16, -1), - Trans(7, 65, 14, -1), - Trans(7, 66, 9, -1), + Trans(7, 62, 9, -1), + Trans(7, 63, 16, -1), + Trans(7, 66, 14, -1), Trans(7, 67, 9, -1), - Trans(7, 71, 17, -1), - Trans(7, 72, 18, -1), - Trans(7, 74, 14, -1), - Trans(7, 78, 9, -1), - Trans(7, 81, 9, -1), + Trans(7, 68, 9, -1), + Trans(7, 72, 17, -1), + Trans(7, 73, 18, -1), + Trans(7, 75, 14, -1), + Trans(7, 79, 9, -1), Trans(7, 82, 9, -1), - Trans(7, 85, 9, -1), - Trans(7, 105, 9, -1), - Trans(7, 108, 9, -1), - Trans(7, 111, 9, -1), - Trans(7, 112, 19, -1), + Trans(7, 83, 9, -1), + Trans(7, 86, 9, -1), + Trans(7, 107, 9, -1), + Trans(7, 110, 9, -1), Trans(7, 113, 9, -1), - Trans(8, 31, 20, 686), - Trans(8, 32, 20, 686), - Trans(8, 37, 20, 686), - Trans(8, 40, 20, 686), - Trans(8, 44, 20, 686), - Trans(8, 49, 20, 686), - Trans(8, 50, 20, 686), - Trans(8, 51, 20, 686), - Trans(8, 61, 20, 686), - Trans(8, 62, 20, 686), - Trans(8, 65, 20, 686), - Trans(8, 66, 20, 686), - Trans(8, 67, 20, 686), - Trans(8, 71, 20, 686), - Trans(8, 72, 20, 686), - Trans(8, 74, 20, 686), - Trans(8, 78, 20, 686), - Trans(8, 81, 20, 686), - Trans(8, 82, 20, 686), - Trans(8, 85, 20, 686), - Trans(8, 105, 20, 686), - Trans(8, 108, 20, 686), - Trans(8, 111, 20, 686), - Trans(8, 112, 20, 686), - Trans(8, 113, 20, 686), - Trans(9, 5, 20, 686), - Trans(9, 115, 20, 686), - Trans(10, 5, 20, 686), - Trans(10, 37, 20, 686), - Trans(10, 40, 20, 686), - Trans(10, 44, 20, 686), - Trans(10, 115, 20, 686), - Trans(11, 5, 20, 686), - Trans(11, 41, 20, 686), - Trans(12, 5, 20, 686), - Trans(12, 31, 20, 686), - Trans(12, 37, 20, 686), - Trans(12, 40, 20, 686), - Trans(12, 44, 20, 686), - Trans(12, 49, 20, 686), - Trans(12, 50, 20, 686), - Trans(12, 51, 20, 686), - Trans(12, 61, 20, 686), - Trans(12, 62, 20, 686), - Trans(12, 65, 20, 686), - Trans(12, 66, 20, 686), - Trans(12, 67, 20, 686), - Trans(12, 71, 20, 686), - Trans(12, 72, 20, 686), - Trans(12, 74, 20, 686), - Trans(12, 78, 20, 686), - Trans(12, 81, 20, 686), - Trans(12, 82, 20, 686), - Trans(12, 85, 20, 686), - Trans(12, 105, 20, 686), - Trans(12, 108, 20, 686), - Trans(12, 111, 20, 686), - Trans(12, 112, 20, 686), - Trans(12, 113, 20, 686), - Trans(13, 0, 20, 686), - Trans(13, 5, 20, 686), - Trans(13, 31, 20, 686), - Trans(13, 32, 20, 686), - Trans(13, 37, 20, 686), - Trans(13, 40, 20, 686), - Trans(13, 44, 20, 686), - Trans(13, 49, 20, 686), - Trans(13, 50, 20, 686), - Trans(13, 51, 20, 686), - Trans(13, 59, 20, 686), - Trans(13, 60, 20, 686), - Trans(13, 61, 20, 686), - Trans(13, 62, 20, 686), - Trans(13, 65, 20, 686), - Trans(13, 66, 20, 686), - Trans(13, 67, 20, 686), - Trans(13, 71, 20, 686), - Trans(13, 72, 20, 686), - Trans(13, 73, 20, 686), - Trans(13, 74, 20, 686), - Trans(13, 78, 20, 686), - Trans(13, 79, 20, 686), - Trans(13, 81, 20, 686), - Trans(13, 82, 20, 686), - Trans(13, 85, 20, 686), - Trans(13, 86, 20, 686), - Trans(13, 90, 20, 686), - Trans(13, 92, 20, 686), - Trans(13, 105, 20, 686), - Trans(13, 108, 20, 686), - Trans(13, 111, 20, 686), - Trans(13, 112, 20, 686), - Trans(13, 113, 20, 686), - Trans(14, 5, 20, 686), - Trans(14, 40, 20, 686), - Trans(15, 5, 20, 686), - Trans(15, 40, 20, 686), - Trans(15, 42, 20, 686), - Trans(16, 5, 20, 686), - Trans(16, 48, 20, 686), - Trans(16, 114, 20, 686), - Trans(16, 115, 20, 686), - Trans(17, 5, 20, 686), - Trans(17, 6, 20, 686), - Trans(17, 7, 20, 686), - Trans(17, 8, 20, 686), - Trans(17, 9, 20, 686), - Trans(17, 10, 20, 686), - Trans(17, 11, 20, 686), - Trans(17, 18, 20, 686), - Trans(17, 24, 20, 686), - Trans(17, 25, 20, 686), - Trans(17, 26, 20, 686), - Trans(17, 27, 20, 686), - Trans(17, 39, 20, 686), - Trans(17, 40, 20, 686), - Trans(17, 42, 20, 686), - Trans(17, 54, 20, 686), - Trans(17, 71, 20, 686), - Trans(17, 77, 20, 686), - Trans(17, 84, 20, 686), - Trans(17, 87, 20, 686), - Trans(17, 89, 20, 686), - Trans(17, 106, 20, 686), - Trans(17, 114, 20, 686), - Trans(17, 115, 20, 686), - Trans(18, 5, 20, 686), - Trans(18, 114, 20, 686), - Trans(18, 115, 20, 686), - Trans(19, 5, 20, 686), - Trans(19, 42, 20, 686), - Trans(21, 5, 20, 686), - Trans(21, 31, 20, 686), - Trans(21, 32, 20, 686), - Trans(21, 37, 20, 686), - Trans(21, 40, 20, 686), - Trans(21, 44, 20, 686), - Trans(21, 49, 20, 686), - Trans(21, 50, 20, 686), - Trans(21, 51, 20, 686), - Trans(21, 61, 20, 686), - Trans(21, 62, 20, 686), - Trans(21, 65, 20, 686), - Trans(21, 66, 20, 686), - Trans(21, 67, 20, 686), - Trans(21, 71, 20, 686), - Trans(21, 72, 20, 686), - Trans(21, 74, 20, 686), - Trans(21, 78, 20, 686), - Trans(21, 81, 20, 686), - Trans(21, 82, 20, 686), - Trans(21, 85, 20, 686), - Trans(21, 105, 20, 686), - Trans(21, 108, 20, 686), - Trans(21, 111, 20, 686), - Trans(21, 112, 20, 686), - Trans(21, 113, 20, 686), + Trans(7, 114, 19, -1), + Trans(7, 115, 9, -1), + Trans(8, 31, 20, 691), + Trans(8, 32, 20, 691), + Trans(8, 37, 20, 691), + Trans(8, 40, 20, 691), + Trans(8, 44, 20, 691), + Trans(8, 49, 20, 691), + Trans(8, 50, 20, 691), + Trans(8, 51, 20, 691), + Trans(8, 62, 20, 691), + Trans(8, 63, 20, 691), + Trans(8, 66, 20, 691), + Trans(8, 67, 20, 691), + Trans(8, 68, 20, 691), + Trans(8, 72, 20, 691), + Trans(8, 73, 20, 691), + Trans(8, 75, 20, 691), + Trans(8, 79, 20, 691), + Trans(8, 82, 20, 691), + Trans(8, 83, 20, 691), + Trans(8, 86, 20, 691), + Trans(8, 107, 20, 691), + Trans(8, 110, 20, 691), + Trans(8, 113, 20, 691), + Trans(8, 114, 20, 691), + Trans(8, 115, 20, 691), + Trans(9, 5, 20, 691), + Trans(9, 117, 20, 691), + Trans(10, 5, 20, 691), + Trans(10, 37, 20, 691), + Trans(10, 40, 20, 691), + Trans(10, 44, 20, 691), + Trans(10, 117, 20, 691), + Trans(11, 5, 20, 691), + Trans(11, 41, 20, 691), + Trans(12, 5, 20, 691), + Trans(12, 31, 20, 691), + Trans(12, 37, 20, 691), + Trans(12, 40, 20, 691), + Trans(12, 44, 20, 691), + Trans(12, 49, 20, 691), + Trans(12, 50, 20, 691), + Trans(12, 51, 20, 691), + Trans(12, 62, 20, 691), + Trans(12, 63, 20, 691), + Trans(12, 66, 20, 691), + Trans(12, 67, 20, 691), + Trans(12, 68, 20, 691), + Trans(12, 72, 20, 691), + Trans(12, 73, 20, 691), + Trans(12, 75, 20, 691), + Trans(12, 79, 20, 691), + Trans(12, 82, 20, 691), + Trans(12, 83, 20, 691), + Trans(12, 86, 20, 691), + Trans(12, 107, 20, 691), + Trans(12, 110, 20, 691), + Trans(12, 113, 20, 691), + Trans(12, 114, 20, 691), + Trans(12, 115, 20, 691), + Trans(13, 0, 20, 691), + Trans(13, 5, 20, 691), + Trans(13, 31, 20, 691), + Trans(13, 32, 20, 691), + Trans(13, 37, 20, 691), + Trans(13, 40, 20, 691), + Trans(13, 44, 20, 691), + Trans(13, 49, 20, 691), + Trans(13, 50, 20, 691), + Trans(13, 51, 20, 691), + Trans(13, 60, 20, 691), + Trans(13, 61, 20, 691), + Trans(13, 62, 20, 691), + Trans(13, 63, 20, 691), + Trans(13, 66, 20, 691), + Trans(13, 67, 20, 691), + Trans(13, 68, 20, 691), + Trans(13, 72, 20, 691), + Trans(13, 73, 20, 691), + Trans(13, 74, 20, 691), + Trans(13, 75, 20, 691), + Trans(13, 79, 20, 691), + Trans(13, 80, 20, 691), + Trans(13, 82, 20, 691), + Trans(13, 83, 20, 691), + Trans(13, 86, 20, 691), + Trans(13, 87, 20, 691), + Trans(13, 91, 20, 691), + Trans(13, 93, 20, 691), + Trans(13, 94, 20, 691), + Trans(13, 107, 20, 691), + Trans(13, 110, 20, 691), + Trans(13, 113, 20, 691), + Trans(13, 114, 20, 691), + Trans(13, 115, 20, 691), + Trans(14, 5, 20, 691), + Trans(14, 40, 20, 691), + Trans(15, 5, 20, 691), + Trans(15, 40, 20, 691), + Trans(15, 42, 20, 691), + Trans(16, 5, 20, 691), + Trans(16, 48, 20, 691), + Trans(16, 116, 20, 691), + Trans(16, 117, 20, 691), + Trans(17, 5, 20, 691), + Trans(17, 6, 20, 691), + Trans(17, 7, 20, 691), + Trans(17, 8, 20, 691), + Trans(17, 9, 20, 691), + Trans(17, 10, 20, 691), + Trans(17, 11, 20, 691), + Trans(17, 18, 20, 691), + Trans(17, 24, 20, 691), + Trans(17, 25, 20, 691), + Trans(17, 26, 20, 691), + Trans(17, 27, 20, 691), + Trans(17, 39, 20, 691), + Trans(17, 40, 20, 691), + Trans(17, 42, 20, 691), + Trans(17, 54, 20, 691), + Trans(17, 72, 20, 691), + Trans(17, 78, 20, 691), + Trans(17, 85, 20, 691), + Trans(17, 88, 20, 691), + Trans(17, 90, 20, 691), + Trans(17, 108, 20, 691), + Trans(17, 116, 20, 691), + Trans(17, 117, 20, 691), + Trans(18, 5, 20, 691), + Trans(18, 116, 20, 691), + Trans(18, 117, 20, 691), + Trans(19, 5, 20, 691), + Trans(19, 42, 20, 691), + Trans(21, 5, 20, 691), + Trans(21, 31, 20, 691), + Trans(21, 32, 20, 691), + Trans(21, 37, 20, 691), + Trans(21, 40, 20, 691), + Trans(21, 44, 20, 691), + Trans(21, 49, 20, 691), + Trans(21, 50, 20, 691), + Trans(21, 51, 20, 691), + Trans(21, 62, 20, 691), + Trans(21, 63, 20, 691), + Trans(21, 66, 20, 691), + Trans(21, 67, 20, 691), + Trans(21, 68, 20, 691), + Trans(21, 72, 20, 691), + Trans(21, 73, 20, 691), + Trans(21, 75, 20, 691), + Trans(21, 79, 20, 691), + Trans(21, 82, 20, 691), + Trans(21, 83, 20, 691), + Trans(21, 86, 20, 691), + Trans(21, 107, 20, 691), + Trans(21, 110, 20, 691), + Trans(21, 113, 20, 691), + Trans(21, 114, 20, 691), + Trans(21, 115, 20, 691), ], k: 3, }, - /* 595 - "StructUnionListOpt" */ + /* 608 - "StructUnionListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 687), Trans(0, 44, 2, 688)], + transitions: &[Trans(0, 32, 1, 692), Trans(0, 44, 2, 693)], k: 1, }, - /* 596 - "Switch" */ + /* 609 - "Switch" */ LookaheadDFA { - prod0: 327, + prod0: 333, transitions: &[], k: 0, }, - /* 597 - "SwitchCondition" */ + /* 610 - "SwitchCondition" */ LookaheadDFA { - prod0: 614, + prod0: 619, transitions: &[], k: 0, }, - /* 598 - "SwitchConditionList" */ + /* 611 - "SwitchConditionList" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 31, 2, 616), Trans(0, 32, 1, 615)], + transitions: &[Trans(0, 31, 2, 621), Trans(0, 32, 1, 620)], k: 1, }, - /* 599 - "SwitchExpression" */ + /* 612 - "SwitchExpression" */ LookaheadDFA { - prod0: 464, + prod0: 470, transitions: &[], k: 0, }, - /* 600 - "SwitchExpressionList" */ + /* 613 - "SwitchExpressionList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 465), - Trans(0, 7, 1, 465), - Trans(0, 8, 1, 465), - Trans(0, 9, 1, 465), - Trans(0, 10, 1, 465), - Trans(0, 11, 1, 465), - Trans(0, 18, 1, 465), - Trans(0, 24, 1, 465), - Trans(0, 25, 1, 465), - Trans(0, 26, 1, 465), - Trans(0, 27, 1, 465), - Trans(0, 39, 1, 465), - Trans(0, 40, 1, 465), - Trans(0, 42, 1, 465), - Trans(0, 54, 1, 465), - Trans(0, 58, 2, 466), - Trans(0, 71, 1, 465), - Trans(0, 77, 1, 465), - Trans(0, 84, 1, 465), - Trans(0, 87, 1, 465), - Trans(0, 89, 1, 465), - Trans(0, 106, 1, 465), - Trans(0, 114, 1, 465), - Trans(0, 115, 1, 465), + Trans(0, 6, 1, 471), + Trans(0, 7, 1, 471), + Trans(0, 8, 1, 471), + Trans(0, 9, 1, 471), + Trans(0, 10, 1, 471), + Trans(0, 11, 1, 471), + Trans(0, 18, 1, 471), + Trans(0, 24, 1, 471), + Trans(0, 25, 1, 471), + Trans(0, 26, 1, 471), + Trans(0, 27, 1, 471), + Trans(0, 39, 1, 471), + Trans(0, 40, 1, 471), + Trans(0, 42, 1, 471), + Trans(0, 54, 1, 471), + Trans(0, 59, 2, 472), + Trans(0, 72, 1, 471), + Trans(0, 78, 1, 471), + Trans(0, 85, 1, 471), + Trans(0, 88, 1, 471), + Trans(0, 90, 1, 471), + Trans(0, 108, 1, 471), + Trans(0, 116, 1, 471), + Trans(0, 117, 1, 471), ], k: 1, }, - /* 601 - "SwitchExpressionOpt" */ + /* 614 - "SwitchExpressionOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 467), Trans(0, 44, 2, 468)], + transitions: &[Trans(0, 32, 1, 473), Trans(0, 44, 2, 474)], k: 1, }, - /* 602 - "SwitchItem" */ + /* 615 - "SwitchItem" */ LookaheadDFA { - prod0: 607, + prod0: 612, transitions: &[], k: 0, }, - /* 603 - "SwitchItemGroup" */ + /* 616 - "SwitchItemGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 612), - Trans(0, 7, 1, 612), - Trans(0, 8, 1, 612), - Trans(0, 9, 1, 612), - Trans(0, 10, 1, 612), - Trans(0, 11, 1, 612), - Trans(0, 18, 1, 612), - Trans(0, 24, 1, 612), - Trans(0, 25, 1, 612), - Trans(0, 26, 1, 612), - Trans(0, 27, 1, 612), - Trans(0, 39, 1, 612), - Trans(0, 40, 1, 612), - Trans(0, 42, 1, 612), - Trans(0, 54, 1, 612), - Trans(0, 58, 2, 613), - Trans(0, 71, 1, 612), - Trans(0, 77, 1, 612), - Trans(0, 84, 1, 612), - Trans(0, 87, 1, 612), - Trans(0, 89, 1, 612), - Trans(0, 106, 1, 612), - Trans(0, 114, 1, 612), - Trans(0, 115, 1, 612), + Trans(0, 6, 1, 617), + Trans(0, 7, 1, 617), + Trans(0, 8, 1, 617), + Trans(0, 9, 1, 617), + Trans(0, 10, 1, 617), + Trans(0, 11, 1, 617), + Trans(0, 18, 1, 617), + Trans(0, 24, 1, 617), + Trans(0, 25, 1, 617), + Trans(0, 26, 1, 617), + Trans(0, 27, 1, 617), + Trans(0, 39, 1, 617), + Trans(0, 40, 1, 617), + Trans(0, 42, 1, 617), + Trans(0, 54, 1, 617), + Trans(0, 59, 2, 618), + Trans(0, 72, 1, 617), + Trans(0, 78, 1, 617), + Trans(0, 85, 1, 617), + Trans(0, 88, 1, 617), + Trans(0, 90, 1, 617), + Trans(0, 108, 1, 617), + Trans(0, 116, 1, 617), + Trans(0, 117, 1, 617), ], k: 1, }, - /* 604 - "SwitchItemGroup0" */ + /* 617 - "SwitchItemGroup0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 40, 2, 609), - Trans(0, 54, 1, 608), - Trans(0, 66, 1, 608), - Trans(0, 70, 1, 608), - Trans(0, 71, 1, 608), - Trans(0, 81, 1, 608), - Trans(0, 100, 1, 608), - Trans(0, 101, 1, 608), - Trans(0, 106, 1, 608), - Trans(0, 114, 1, 608), - Trans(0, 115, 1, 608), + Trans(0, 40, 2, 614), + Trans(0, 54, 1, 613), + Trans(0, 67, 1, 613), + Trans(0, 71, 1, 613), + Trans(0, 72, 1, 613), + Trans(0, 82, 1, 613), + Trans(0, 102, 1, 613), + Trans(0, 103, 1, 613), + Trans(0, 108, 1, 613), + Trans(0, 116, 1, 613), + Trans(0, 117, 1, 613), ], k: 1, }, - /* 605 - "SwitchItemGroup0List" */ + /* 618 - "SwitchItemGroup0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 44, 2, 611), - Trans(0, 54, 1, 610), - Trans(0, 66, 1, 610), - Trans(0, 70, 1, 610), - Trans(0, 71, 1, 610), - Trans(0, 81, 1, 610), - Trans(0, 100, 1, 610), - Trans(0, 101, 1, 610), - Trans(0, 106, 1, 610), - Trans(0, 114, 1, 610), - Trans(0, 115, 1, 610), + Trans(0, 44, 2, 616), + Trans(0, 54, 1, 615), + Trans(0, 67, 1, 615), + Trans(0, 71, 1, 615), + Trans(0, 72, 1, 615), + Trans(0, 82, 1, 615), + Trans(0, 102, 1, 615), + Trans(0, 103, 1, 615), + Trans(0, 108, 1, 615), + Trans(0, 116, 1, 615), + Trans(0, 117, 1, 615), ], k: 1, }, - /* 606 - "SwitchStatement" */ + /* 619 - "SwitchStatement" */ LookaheadDFA { - prod0: 604, + prod0: 609, transitions: &[], k: 0, }, - /* 607 - "SwitchStatementList" */ + /* 620 - "SwitchStatementList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 605), - Trans(0, 7, 1, 605), - Trans(0, 8, 1, 605), - Trans(0, 9, 1, 605), - Trans(0, 10, 1, 605), - Trans(0, 11, 1, 605), - Trans(0, 18, 1, 605), - Trans(0, 24, 1, 605), - Trans(0, 25, 1, 605), - Trans(0, 26, 1, 605), - Trans(0, 27, 1, 605), - Trans(0, 39, 1, 605), - Trans(0, 40, 1, 605), - Trans(0, 42, 1, 605), - Trans(0, 44, 2, 606), - Trans(0, 54, 1, 605), - Trans(0, 58, 1, 605), - Trans(0, 71, 1, 605), - Trans(0, 77, 1, 605), - Trans(0, 84, 1, 605), - Trans(0, 87, 1, 605), - Trans(0, 89, 1, 605), - Trans(0, 106, 1, 605), - Trans(0, 114, 1, 605), - Trans(0, 115, 1, 605), + Trans(0, 6, 1, 610), + Trans(0, 7, 1, 610), + Trans(0, 8, 1, 610), + Trans(0, 9, 1, 610), + Trans(0, 10, 1, 610), + Trans(0, 11, 1, 610), + Trans(0, 18, 1, 610), + Trans(0, 24, 1, 610), + Trans(0, 25, 1, 610), + Trans(0, 26, 1, 610), + Trans(0, 27, 1, 610), + Trans(0, 39, 1, 610), + Trans(0, 40, 1, 610), + Trans(0, 42, 1, 610), + Trans(0, 44, 2, 611), + Trans(0, 54, 1, 610), + Trans(0, 59, 1, 610), + Trans(0, 72, 1, 610), + Trans(0, 78, 1, 610), + Trans(0, 85, 1, 610), + Trans(0, 88, 1, 610), + Trans(0, 90, 1, 610), + Trans(0, 108, 1, 610), + Trans(0, 116, 1, 610), + Trans(0, 117, 1, 610), ], k: 1, }, - /* 608 - "SwitchTerm" */ + /* 621 - "SwitchTerm" */ LookaheadDFA { - prod0: 101, + prod0: 103, transitions: &[], k: 0, }, - /* 609 - "SwitchToken" */ + /* 622 - "SwitchToken" */ LookaheadDFA { - prod0: 216, + prod0: 220, transitions: &[], k: 0, }, - /* 610 - "Tri" */ + /* 623 - "Tri" */ LookaheadDFA { - prod0: 328, + prod0: 334, transitions: &[], k: 0, }, - /* 611 - "TriTerm" */ + /* 624 - "TriTerm" */ LookaheadDFA { - prod0: 102, + prod0: 104, transitions: &[], k: 0, }, - /* 612 - "TriToken" */ + /* 625 - "TriToken" */ LookaheadDFA { - prod0: 217, + prod0: 221, transitions: &[], k: 0, }, - /* 613 - "Type" */ + /* 626 - "Type" */ LookaheadDFA { - prod0: 329, + prod0: 335, transitions: &[], k: 0, }, - /* 614 - "TypeDefDeclaration" */ + /* 627 - "TypeDefDeclaration" */ LookaheadDFA { - prod0: 636, + prod0: 641, transitions: &[], k: 0, }, - /* 615 - "TypeExpression" */ + /* 628 - "TypeExpression" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 53, 1, 469), - Trans(0, 55, 1, 469), - Trans(0, 56, 1, 469), - Trans(0, 57, 1, 469), - Trans(0, 63, 1, 469), - Trans(0, 64, 1, 469), - Trans(0, 68, 1, 469), - Trans(0, 69, 1, 469), - Trans(0, 83, 1, 469), - Trans(0, 95, 1, 469), - Trans(0, 96, 1, 469), - Trans(0, 97, 1, 469), - Trans(0, 98, 1, 469), - Trans(0, 99, 1, 469), - Trans(0, 102, 1, 469), - Trans(0, 104, 1, 469), - Trans(0, 107, 1, 469), - Trans(0, 108, 2, 470), - Trans(0, 109, 1, 469), - Trans(0, 110, 1, 469), - Trans(0, 114, 1, 469), - Trans(0, 115, 1, 469), + Trans(0, 53, 1, 475), + Trans(0, 55, 1, 475), + Trans(0, 56, 1, 475), + Trans(0, 57, 1, 475), + Trans(0, 64, 1, 475), + Trans(0, 65, 1, 475), + Trans(0, 69, 1, 475), + Trans(0, 70, 1, 475), + Trans(0, 84, 1, 475), + Trans(0, 97, 1, 475), + Trans(0, 98, 1, 475), + Trans(0, 99, 1, 475), + Trans(0, 100, 1, 475), + Trans(0, 101, 1, 475), + Trans(0, 104, 1, 475), + Trans(0, 106, 1, 475), + Trans(0, 109, 1, 475), + Trans(0, 110, 2, 476), + Trans(0, 111, 1, 475), + Trans(0, 112, 1, 475), + Trans(0, 116, 1, 475), + Trans(0, 117, 1, 475), ], k: 1, }, - /* 616 - "TypeModifier" */ + /* 629 - "TypeModifier" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 102, 2, 519), Trans(0, 107, 1, 518)], + transitions: &[Trans(0, 104, 2, 522), Trans(0, 109, 1, 521)], k: 1, }, - /* 617 - "TypeTerm" */ + /* 630 - "TypeTerm" */ LookaheadDFA { - prod0: 103, + prod0: 105, transitions: &[], k: 0, }, - /* 618 - "TypeToken" */ + /* 631 - "TypeToken" */ LookaheadDFA { - prod0: 218, + prod0: 222, transitions: &[], k: 0, }, - /* 619 - "U32" */ + /* 632 - "U32" */ LookaheadDFA { - prod0: 330, + prod0: 336, transitions: &[], k: 0, }, - /* 620 - "U32Term" */ + /* 633 - "U32Term" */ LookaheadDFA { - prod0: 104, + prod0: 106, transitions: &[], k: 0, }, - /* 621 - "U32Token" */ + /* 634 - "U32Token" */ LookaheadDFA { - prod0: 219, + prod0: 223, transitions: &[], k: 0, }, - /* 622 - "U64" */ + /* 635 - "U64" */ LookaheadDFA { - prod0: 331, + prod0: 337, transitions: &[], k: 0, }, - /* 623 - "U64Term" */ + /* 636 - "U64Term" */ LookaheadDFA { - prod0: 105, + prod0: 107, transitions: &[], k: 0, }, - /* 624 - "U64Token" */ + /* 637 - "U64Token" */ LookaheadDFA { - prod0: 220, + prod0: 224, transitions: &[], k: 0, }, - /* 625 - "UnaryOperator" */ + /* 638 - "UnaryOperator" */ LookaheadDFA { - prod0: 245, + prod0: 249, transitions: &[], k: 0, }, - /* 626 - "UnaryOperatorTerm" */ + /* 639 - "UnaryOperatorTerm" */ LookaheadDFA { prod0: 22, transitions: &[], k: 0, }, - /* 627 - "UnaryOperatorToken" */ + /* 640 - "UnaryOperatorToken" */ LookaheadDFA { - prod0: 134, + prod0: 136, transitions: &[], k: 0, }, - /* 628 - "Union" */ + /* 641 - "Union" */ LookaheadDFA { - prod0: 332, + prod0: 338, transitions: &[], k: 0, }, - /* 629 - "UnionTerm" */ + /* 642 - "UnionTerm" */ LookaheadDFA { - prod0: 106, + prod0: 108, transitions: &[], k: 0, }, - /* 630 - "UnionToken" */ + /* 643 - "UnionToken" */ LookaheadDFA { - prod0: 221, + prod0: 225, transitions: &[], k: 0, }, - /* 631 - "Unsafe" */ + /* 644 - "Unsafe" */ LookaheadDFA { - prod0: 333, + prod0: 339, transitions: &[], k: 0, }, - /* 632 - "UnsafeBlock" */ + /* 645 - "UnsafeBlock" */ LookaheadDFA { - prod0: 825, + prod0: 833, transitions: &[], k: 0, }, - /* 633 - "UnsafeBlockList" */ + /* 646 - "UnsafeBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 31, 1, 826), - Trans(0, 37, 1, 826), - Trans(0, 40, 1, 826), - Trans(0, 44, 2, 827), - Trans(0, 49, 1, 826), - Trans(0, 50, 1, 826), - Trans(0, 51, 1, 826), - Trans(0, 61, 1, 826), - Trans(0, 65, 1, 826), - Trans(0, 66, 1, 826), - Trans(0, 67, 1, 826), - Trans(0, 71, 1, 826), - Trans(0, 72, 1, 826), - Trans(0, 74, 1, 826), - Trans(0, 78, 1, 826), - Trans(0, 81, 1, 826), - Trans(0, 82, 1, 826), - Trans(0, 105, 1, 826), - Trans(0, 108, 1, 826), - Trans(0, 111, 1, 826), - Trans(0, 112, 1, 826), - Trans(0, 113, 1, 826), + Trans(0, 31, 1, 834), + Trans(0, 37, 1, 834), + Trans(0, 40, 1, 834), + Trans(0, 44, 2, 835), + Trans(0, 49, 1, 834), + Trans(0, 50, 1, 834), + Trans(0, 51, 1, 834), + Trans(0, 62, 1, 834), + Trans(0, 66, 1, 834), + Trans(0, 67, 1, 834), + Trans(0, 68, 1, 834), + Trans(0, 72, 1, 834), + Trans(0, 73, 1, 834), + Trans(0, 75, 1, 834), + Trans(0, 79, 1, 834), + Trans(0, 82, 1, 834), + Trans(0, 83, 1, 834), + Trans(0, 107, 1, 834), + Trans(0, 110, 1, 834), + Trans(0, 113, 1, 834), + Trans(0, 114, 1, 834), + Trans(0, 115, 1, 834), ], k: 1, }, - /* 634 - "UnsafeTerm" */ + /* 647 - "UnsafeTerm" */ LookaheadDFA { - prod0: 107, + prod0: 109, transitions: &[], k: 0, }, - /* 635 - "UnsafeToken" */ + /* 648 - "UnsafeToken" */ LookaheadDFA { - prod0: 222, + prod0: 226, transitions: &[], k: 0, }, - /* 636 - "Var" */ + /* 649 - "Var" */ LookaheadDFA { - prod0: 334, + prod0: 340, transitions: &[], k: 0, }, - /* 637 - "VarDeclaration" */ + /* 650 - "VarDeclaration" */ LookaheadDFA { - prod0: 630, + prod0: 635, transitions: &[], k: 0, }, - /* 638 - "VarDeclarationOpt" */ + /* 651 - "VarDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 28, 1, 631), - Trans(0, 53, 2, 632), - Trans(0, 55, 2, 632), - Trans(0, 56, 2, 632), - Trans(0, 57, 2, 632), - Trans(0, 63, 2, 632), - Trans(0, 64, 2, 632), - Trans(0, 68, 2, 632), - Trans(0, 69, 2, 632), - Trans(0, 83, 2, 632), - Trans(0, 95, 2, 632), - Trans(0, 96, 2, 632), - Trans(0, 97, 2, 632), - Trans(0, 98, 2, 632), - Trans(0, 99, 2, 632), - Trans(0, 102, 2, 632), - Trans(0, 104, 2, 632), - Trans(0, 107, 2, 632), - Trans(0, 109, 2, 632), - Trans(0, 110, 2, 632), - Trans(0, 114, 2, 632), - Trans(0, 115, 2, 632), + Trans(0, 28, 1, 636), + Trans(0, 53, 2, 637), + Trans(0, 55, 2, 637), + Trans(0, 56, 2, 637), + Trans(0, 57, 2, 637), + Trans(0, 64, 2, 637), + Trans(0, 65, 2, 637), + Trans(0, 69, 2, 637), + Trans(0, 70, 2, 637), + Trans(0, 84, 2, 637), + Trans(0, 97, 2, 637), + Trans(0, 98, 2, 637), + Trans(0, 99, 2, 637), + Trans(0, 100, 2, 637), + Trans(0, 101, 2, 637), + Trans(0, 104, 2, 637), + Trans(0, 106, 2, 637), + Trans(0, 109, 2, 637), + Trans(0, 111, 2, 637), + Trans(0, 112, 2, 637), + Trans(0, 116, 2, 637), + Trans(0, 117, 2, 637), ], k: 1, }, - /* 639 - "VarTerm" */ - LookaheadDFA { - prod0: 108, - transitions: &[], - k: 0, - }, - /* 640 - "VarToken" */ + /* 652 - "VarTerm" */ LookaheadDFA { - prod0: 223, + prod0: 110, transitions: &[], k: 0, }, - /* 641 - "VariableType" */ + /* 653 - "VarToken" */ LookaheadDFA { - prod0: 504, + prod0: 227, transitions: &[], k: 0, }, - /* 642 - "VariableTypeGroup" */ - LookaheadDFA { - prod0: -1, - transitions: &[ - Trans(0, 53, 10, 514), - Trans(0, 55, 1, 505), - Trans(0, 56, 2, 506), - Trans(0, 57, 3, 507), - Trans(0, 83, 9, 513), - Trans(0, 95, 4, 508), - Trans(0, 96, 5, 509), - Trans(0, 97, 6, 510), - Trans(0, 98, 7, 511), - Trans(0, 99, 8, 512), - Trans(0, 114, 11, 515), - Trans(0, 115, 11, 515), - ], - k: 1, - }, - /* 643 - "VariableTypeOpt" */ + /* 654 - "VariableType" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 2, 517), - Trans(0, 36, 2, 517), - Trans(0, 38, 1, 516), - Trans(0, 40, 2, 517), - Trans(0, 41, 2, 517), - Trans(0, 44, 2, 517), - Trans(0, 46, 2, 517), - Trans(0, 47, 2, 517), - Trans(0, 80, 2, 517), + Trans(0, 53, 10, 519), + Trans(0, 55, 1, 510), + Trans(0, 56, 2, 511), + Trans(0, 57, 3, 512), + Trans(0, 84, 9, 518), + Trans(0, 97, 4, 513), + Trans(0, 98, 5, 514), + Trans(0, 99, 6, 515), + Trans(0, 100, 7, 516), + Trans(0, 101, 8, 517), + Trans(0, 116, 11, 520), + Trans(0, 117, 11, 520), ], k: 1, }, - /* 644 - "Veryl" */ + /* 655 - "Veryl" */ LookaheadDFA { - prod0: 973, + prod0: 991, transitions: &[], k: 0, }, - /* 645 - "VerylList" */ + /* 656 - "VerylList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 0, 2, 975), - Trans(0, 37, 1, 974), - Trans(0, 40, 1, 974), - Trans(0, 60, 1, 974), - Trans(0, 72, 1, 974), - Trans(0, 73, 1, 974), - Trans(0, 79, 1, 974), - Trans(0, 86, 1, 974), - Trans(0, 90, 1, 974), - Trans(0, 92, 1, 974), + Trans(0, 0, 2, 993), + Trans(0, 37, 1, 992), + Trans(0, 40, 1, 992), + Trans(0, 61, 1, 992), + Trans(0, 73, 1, 992), + Trans(0, 74, 1, 992), + Trans(0, 80, 1, 992), + Trans(0, 87, 1, 992), + Trans(0, 91, 1, 992), + Trans(0, 93, 1, 992), + Trans(0, 94, 1, 992), ], k: 1, }, - /* 646 - "Width" */ + /* 657 - "Width" */ LookaheadDFA { - prod0: 486, + prod0: 492, transitions: &[], k: 0, }, - /* 647 - "WidthList" */ + /* 658 - "WidthList" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 487), Trans(0, 43, 2, 488)], + transitions: &[Trans(0, 32, 1, 493), Trans(0, 43, 2, 494)], k: 1, }, - /* 648 - "WithGenericArgument" */ + /* 659 - "WithGenericArgument" */ LookaheadDFA { - prod0: 766, + prod0: 774, transitions: &[], k: 0, }, - /* 649 - "WithGenericArgumentItem" */ + /* 660 - "WithGenericArgumentItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 7, 2, 775), - Trans(0, 8, 2, 775), - Trans(0, 9, 2, 775), - Trans(0, 10, 2, 775), - Trans(0, 11, 2, 775), - Trans(0, 114, 1, 774), - Trans(0, 115, 1, 774), + Trans(0, 7, 2, 783), + Trans(0, 8, 2, 783), + Trans(0, 9, 2, 783), + Trans(0, 10, 2, 783), + Trans(0, 11, 2, 783), + Trans(0, 116, 1, 782), + Trans(0, 117, 1, 782), ], k: 1, }, - /* 650 - "WithGenericArgumentList" */ + /* 661 - "WithGenericArgumentList" */ LookaheadDFA { - prod0: 769, + prod0: 777, transitions: &[], k: 0, }, - /* 651 - "WithGenericArgumentListList" */ + /* 662 - "WithGenericArgumentListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -16775,28 +16917,28 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 10, 2, -1), Trans(1, 11, 2, -1), Trans(1, 43, 25, -1), - Trans(1, 114, 4, -1), - Trans(1, 115, 5, -1), - Trans(2, 5, 3, 770), - Trans(2, 32, 3, 770), - Trans(2, 43, 3, 770), - Trans(4, 5, 3, 770), - Trans(4, 30, 3, 770), - Trans(4, 32, 3, 770), - Trans(4, 43, 3, 770), - Trans(5, 5, 3, 770), - Trans(5, 29, 3, 770), - Trans(5, 30, 3, 770), - Trans(5, 32, 3, 770), - Trans(5, 43, 3, 770), - Trans(6, 7, 3, 770), - Trans(6, 8, 3, 770), - Trans(6, 9, 3, 770), - Trans(6, 10, 3, 770), - Trans(6, 11, 3, 770), - Trans(6, 43, 24, 771), - Trans(6, 114, 3, 770), - Trans(6, 115, 3, 770), + Trans(1, 116, 4, -1), + Trans(1, 117, 5, -1), + Trans(2, 5, 3, 778), + Trans(2, 32, 3, 778), + Trans(2, 43, 3, 778), + Trans(4, 5, 3, 778), + Trans(4, 30, 3, 778), + Trans(4, 32, 3, 778), + Trans(4, 43, 3, 778), + Trans(5, 5, 3, 778), + Trans(5, 29, 3, 778), + Trans(5, 30, 3, 778), + Trans(5, 32, 3, 778), + Trans(5, 43, 3, 778), + Trans(6, 7, 3, 778), + Trans(6, 8, 3, 778), + Trans(6, 9, 3, 778), + Trans(6, 10, 3, 778), + Trans(6, 11, 3, 778), + Trans(6, 43, 24, 779), + Trans(6, 116, 3, 778), + Trans(6, 117, 3, 778), Trans(7, 5, 8, -1), Trans(7, 12, 9, -1), Trans(7, 14, 9, -1), @@ -16831,731 +16973,737 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(7, 47, 21, -1), Trans(7, 48, 9, -1), Trans(7, 52, 22, -1), - Trans(7, 80, 9, -1), - Trans(7, 94, 9, -1), - Trans(7, 103, 23, -1), - Trans(8, 12, 24, 771), - Trans(8, 14, 24, 771), - Trans(8, 15, 24, 771), - Trans(8, 16, 24, 771), - Trans(8, 17, 24, 771), - Trans(8, 18, 24, 771), - Trans(8, 19, 24, 771), - Trans(8, 20, 24, 771), - Trans(8, 21, 24, 771), - Trans(8, 22, 24, 771), - Trans(8, 23, 24, 771), - Trans(8, 24, 24, 771), - Trans(8, 25, 24, 771), - Trans(8, 26, 24, 771), - Trans(8, 30, 24, 771), - Trans(8, 31, 24, 771), - Trans(8, 32, 24, 771), - Trans(8, 33, 24, 771), - Trans(8, 34, 24, 771), - Trans(8, 35, 24, 771), - Trans(8, 36, 24, 771), - Trans(8, 37, 24, 771), - Trans(8, 38, 24, 771), - Trans(8, 40, 24, 771), - Trans(8, 41, 24, 771), - Trans(8, 42, 24, 771), - Trans(8, 43, 24, 771), - Trans(8, 44, 24, 771), - Trans(8, 45, 24, 771), - Trans(8, 46, 24, 771), - Trans(8, 47, 24, 771), - Trans(8, 48, 24, 771), - Trans(8, 52, 24, 771), - Trans(8, 80, 24, 771), - Trans(8, 94, 24, 771), - Trans(8, 103, 24, 771), - Trans(9, 5, 24, 771), - Trans(9, 6, 24, 771), - Trans(9, 7, 24, 771), - Trans(9, 8, 24, 771), - Trans(9, 9, 24, 771), - Trans(9, 10, 24, 771), - Trans(9, 11, 24, 771), - Trans(9, 18, 24, 771), - Trans(9, 24, 24, 771), - Trans(9, 25, 24, 771), - Trans(9, 26, 24, 771), - Trans(9, 27, 24, 771), - Trans(9, 39, 24, 771), - Trans(9, 40, 24, 771), - Trans(9, 42, 24, 771), - Trans(9, 54, 24, 771), - Trans(9, 71, 24, 771), - Trans(9, 77, 24, 771), - Trans(9, 84, 24, 771), - Trans(9, 87, 24, 771), - Trans(9, 89, 24, 771), - Trans(9, 106, 24, 771), - Trans(9, 114, 24, 771), - Trans(9, 115, 24, 771), - Trans(10, 5, 24, 771), - Trans(10, 48, 24, 771), - Trans(10, 115, 24, 771), - Trans(11, 5, 24, 771), - Trans(11, 6, 24, 771), - Trans(11, 7, 24, 771), - Trans(11, 8, 24, 771), - Trans(11, 9, 24, 771), - Trans(11, 10, 24, 771), - Trans(11, 11, 24, 771), - Trans(11, 18, 24, 771), - Trans(11, 24, 24, 771), - Trans(11, 25, 24, 771), - Trans(11, 26, 24, 771), - Trans(11, 27, 24, 771), - Trans(11, 39, 24, 771), - Trans(11, 40, 24, 771), - Trans(11, 42, 24, 771), - Trans(11, 54, 24, 771), - Trans(11, 66, 24, 771), - Trans(11, 70, 24, 771), - Trans(11, 71, 24, 771), - Trans(11, 77, 24, 771), - Trans(11, 81, 24, 771), - Trans(11, 84, 24, 771), - Trans(11, 87, 24, 771), - Trans(11, 89, 24, 771), - Trans(11, 100, 24, 771), - Trans(11, 101, 24, 771), - Trans(11, 106, 24, 771), - Trans(11, 114, 24, 771), - Trans(11, 115, 24, 771), - Trans(12, 5, 24, 771), - Trans(12, 6, 24, 771), - Trans(12, 7, 24, 771), - Trans(12, 8, 24, 771), - Trans(12, 9, 24, 771), - Trans(12, 10, 24, 771), - Trans(12, 11, 24, 771), - Trans(12, 18, 24, 771), - Trans(12, 24, 24, 771), - Trans(12, 25, 24, 771), - Trans(12, 26, 24, 771), - Trans(12, 27, 24, 771), - Trans(12, 37, 24, 771), - Trans(12, 39, 24, 771), - Trans(12, 40, 24, 771), - Trans(12, 42, 24, 771), - Trans(12, 43, 24, 771), - Trans(12, 44, 24, 771), - Trans(12, 46, 24, 771), - Trans(12, 54, 24, 771), - Trans(12, 58, 24, 771), - Trans(12, 71, 24, 771), - Trans(12, 77, 24, 771), - Trans(12, 82, 24, 771), - Trans(12, 84, 24, 771), - Trans(12, 87, 24, 771), - Trans(12, 89, 24, 771), - Trans(12, 91, 24, 771), - Trans(12, 106, 24, 771), - Trans(12, 114, 24, 771), - Trans(12, 115, 24, 771), - Trans(13, 5, 24, 771), - Trans(13, 115, 24, 771), - Trans(14, 5, 24, 771), - Trans(14, 42, 24, 771), - Trans(15, 5, 24, 771), - Trans(15, 6, 24, 771), - Trans(15, 7, 24, 771), - Trans(15, 8, 24, 771), - Trans(15, 9, 24, 771), - Trans(15, 10, 24, 771), - Trans(15, 11, 24, 771), - Trans(15, 18, 24, 771), - Trans(15, 24, 24, 771), - Trans(15, 25, 24, 771), - Trans(15, 26, 24, 771), - Trans(15, 27, 24, 771), - Trans(15, 31, 24, 771), - Trans(15, 37, 24, 771), - Trans(15, 39, 24, 771), - Trans(15, 40, 24, 771), - Trans(15, 42, 24, 771), - Trans(15, 44, 24, 771), - Trans(15, 49, 24, 771), - Trans(15, 50, 24, 771), - Trans(15, 51, 24, 771), - Trans(15, 54, 24, 771), - Trans(15, 58, 24, 771), - Trans(15, 61, 24, 771), - Trans(15, 65, 24, 771), - Trans(15, 66, 24, 771), - Trans(15, 67, 24, 771), - Trans(15, 70, 24, 771), - Trans(15, 71, 24, 771), - Trans(15, 72, 24, 771), - Trans(15, 74, 24, 771), - Trans(15, 77, 24, 771), - Trans(15, 78, 24, 771), - Trans(15, 81, 24, 771), - Trans(15, 82, 24, 771), - Trans(15, 84, 24, 771), - Trans(15, 85, 24, 771), - Trans(15, 87, 24, 771), - Trans(15, 89, 24, 771), - Trans(15, 100, 24, 771), - Trans(15, 101, 24, 771), - Trans(15, 105, 24, 771), - Trans(15, 106, 24, 771), - Trans(15, 108, 24, 771), - Trans(15, 111, 24, 771), - Trans(15, 112, 24, 771), - Trans(15, 113, 24, 771), - Trans(15, 114, 24, 771), - Trans(15, 115, 24, 771), - Trans(16, 5, 24, 771), - Trans(16, 6, 24, 771), - Trans(16, 7, 24, 771), - Trans(16, 8, 24, 771), - Trans(16, 9, 24, 771), - Trans(16, 10, 24, 771), - Trans(16, 11, 24, 771), - Trans(16, 18, 24, 771), - Trans(16, 24, 24, 771), - Trans(16, 25, 24, 771), - Trans(16, 26, 24, 771), - Trans(16, 27, 24, 771), - Trans(16, 37, 24, 771), - Trans(16, 39, 24, 771), - Trans(16, 40, 24, 771), - Trans(16, 42, 24, 771), - Trans(16, 46, 24, 771), - Trans(16, 54, 24, 771), - Trans(16, 71, 24, 771), - Trans(16, 77, 24, 771), - Trans(16, 84, 24, 771), - Trans(16, 87, 24, 771), - Trans(16, 89, 24, 771), - Trans(16, 106, 24, 771), - Trans(16, 114, 24, 771), - Trans(16, 115, 24, 771), - Trans(17, 5, 24, 771), - Trans(17, 12, 24, 771), - Trans(17, 13, 24, 771), - Trans(17, 14, 24, 771), - Trans(17, 15, 24, 771), - Trans(17, 16, 24, 771), - Trans(17, 17, 24, 771), - Trans(17, 18, 24, 771), - Trans(17, 19, 24, 771), - Trans(17, 20, 24, 771), - Trans(17, 21, 24, 771), - Trans(17, 22, 24, 771), - Trans(17, 23, 24, 771), - Trans(17, 24, 24, 771), - Trans(17, 25, 24, 771), - Trans(17, 26, 24, 771), - Trans(17, 30, 24, 771), - Trans(17, 31, 24, 771), - Trans(17, 32, 24, 771), - Trans(17, 33, 24, 771), - Trans(17, 34, 24, 771), - Trans(17, 35, 24, 771), - Trans(17, 36, 24, 771), - Trans(17, 37, 24, 771), - Trans(17, 38, 24, 771), - Trans(17, 40, 24, 771), - Trans(17, 41, 24, 771), - Trans(17, 42, 24, 771), - Trans(17, 43, 24, 771), - Trans(17, 44, 24, 771), - Trans(17, 45, 24, 771), - Trans(17, 46, 24, 771), - Trans(17, 47, 24, 771), - Trans(17, 48, 24, 771), - Trans(17, 52, 24, 771), - Trans(17, 80, 24, 771), - Trans(17, 94, 24, 771), - Trans(17, 103, 24, 771), - Trans(18, 5, 24, 771), - Trans(18, 12, 24, 771), - Trans(18, 14, 24, 771), - Trans(18, 16, 24, 771), - Trans(18, 17, 24, 771), - Trans(18, 18, 24, 771), - Trans(18, 19, 24, 771), - Trans(18, 20, 24, 771), - Trans(18, 21, 24, 771), - Trans(18, 22, 24, 771), - Trans(18, 23, 24, 771), - Trans(18, 24, 24, 771), - Trans(18, 25, 24, 771), - Trans(18, 26, 24, 771), - Trans(18, 31, 24, 771), - Trans(18, 32, 24, 771), - Trans(18, 33, 24, 771), - Trans(18, 34, 24, 771), - Trans(18, 37, 24, 771), - Trans(18, 40, 24, 771), - Trans(18, 43, 24, 771), - Trans(18, 44, 24, 771), - Trans(18, 45, 24, 771), - Trans(18, 46, 24, 771), - Trans(18, 47, 24, 771), - Trans(18, 48, 24, 771), - Trans(18, 49, 24, 771), - Trans(18, 50, 24, 771), - Trans(18, 51, 24, 771), - Trans(18, 52, 24, 771), - Trans(18, 59, 24, 771), - Trans(18, 61, 24, 771), - Trans(18, 62, 24, 771), - Trans(18, 65, 24, 771), - Trans(18, 66, 24, 771), - Trans(18, 67, 24, 771), - Trans(18, 71, 24, 771), - Trans(18, 72, 24, 771), - Trans(18, 74, 24, 771), - Trans(18, 78, 24, 771), - Trans(18, 81, 24, 771), - Trans(18, 82, 24, 771), - Trans(18, 85, 24, 771), - Trans(18, 94, 24, 771), - Trans(18, 103, 24, 771), - Trans(18, 105, 24, 771), - Trans(18, 108, 24, 771), - Trans(18, 111, 24, 771), - Trans(18, 112, 24, 771), - Trans(18, 113, 24, 771), - Trans(19, 5, 24, 771), - Trans(19, 12, 24, 771), - Trans(19, 14, 24, 771), - Trans(19, 15, 24, 771), - Trans(19, 16, 24, 771), - Trans(19, 17, 24, 771), - Trans(19, 18, 24, 771), - Trans(19, 19, 24, 771), - Trans(19, 20, 24, 771), - Trans(19, 21, 24, 771), - Trans(19, 22, 24, 771), - Trans(19, 23, 24, 771), - Trans(19, 24, 24, 771), - Trans(19, 25, 24, 771), - Trans(19, 26, 24, 771), - Trans(19, 31, 24, 771), - Trans(19, 32, 24, 771), - Trans(19, 33, 24, 771), - Trans(19, 34, 24, 771), - Trans(19, 35, 24, 771), - Trans(19, 36, 24, 771), - Trans(19, 37, 24, 771), - Trans(19, 40, 24, 771), - Trans(19, 41, 24, 771), - Trans(19, 42, 24, 771), - Trans(19, 43, 24, 771), - Trans(19, 44, 24, 771), - Trans(19, 45, 24, 771), - Trans(19, 46, 24, 771), - Trans(19, 47, 24, 771), - Trans(19, 48, 24, 771), - Trans(19, 52, 24, 771), - Trans(19, 94, 24, 771), - Trans(19, 103, 24, 771), - Trans(20, 5, 24, 771), - Trans(20, 12, 24, 771), - Trans(20, 13, 24, 771), - Trans(20, 14, 24, 771), - Trans(20, 16, 24, 771), - Trans(20, 17, 24, 771), - Trans(20, 18, 24, 771), - Trans(20, 19, 24, 771), - Trans(20, 20, 24, 771), - Trans(20, 21, 24, 771), - Trans(20, 22, 24, 771), - Trans(20, 23, 24, 771), - Trans(20, 24, 24, 771), - Trans(20, 25, 24, 771), - Trans(20, 26, 24, 771), - Trans(20, 31, 24, 771), - Trans(20, 32, 24, 771), - Trans(20, 33, 24, 771), - Trans(20, 34, 24, 771), - Trans(20, 40, 24, 771), - Trans(20, 42, 24, 771), - Trans(20, 43, 24, 771), - Trans(20, 44, 24, 771), - Trans(20, 45, 24, 771), - Trans(20, 46, 24, 771), - Trans(20, 47, 24, 771), - Trans(20, 48, 24, 771), - Trans(20, 52, 24, 771), - Trans(20, 94, 24, 771), - Trans(20, 103, 24, 771), - Trans(21, 0, 24, 771), - Trans(21, 5, 24, 771), - Trans(21, 6, 24, 771), - Trans(21, 7, 24, 771), - Trans(21, 8, 24, 771), - Trans(21, 9, 24, 771), - Trans(21, 10, 24, 771), - Trans(21, 11, 24, 771), - Trans(21, 18, 24, 771), - Trans(21, 24, 24, 771), - Trans(21, 25, 24, 771), - Trans(21, 26, 24, 771), - Trans(21, 27, 24, 771), - Trans(21, 31, 24, 771), - Trans(21, 37, 24, 771), - Trans(21, 39, 24, 771), - Trans(21, 40, 24, 771), - Trans(21, 42, 24, 771), - Trans(21, 44, 24, 771), - Trans(21, 49, 24, 771), - Trans(21, 50, 24, 771), - Trans(21, 51, 24, 771), - Trans(21, 54, 24, 771), - Trans(21, 58, 24, 771), - Trans(21, 60, 24, 771), - Trans(21, 61, 24, 771), - Trans(21, 62, 24, 771), - Trans(21, 65, 24, 771), - Trans(21, 66, 24, 771), - Trans(21, 67, 24, 771), - Trans(21, 70, 24, 771), - Trans(21, 71, 24, 771), - Trans(21, 72, 24, 771), - Trans(21, 73, 24, 771), - Trans(21, 74, 24, 771), - Trans(21, 77, 24, 771), - Trans(21, 78, 24, 771), - Trans(21, 79, 24, 771), - Trans(21, 81, 24, 771), - Trans(21, 82, 24, 771), - Trans(21, 84, 24, 771), - Trans(21, 85, 24, 771), - Trans(21, 86, 24, 771), - Trans(21, 87, 24, 771), - Trans(21, 89, 24, 771), - Trans(21, 90, 24, 771), - Trans(21, 92, 24, 771), - Trans(21, 100, 24, 771), - Trans(21, 101, 24, 771), - Trans(21, 105, 24, 771), - Trans(21, 106, 24, 771), - Trans(21, 108, 24, 771), - Trans(21, 111, 24, 771), - Trans(21, 112, 24, 771), - Trans(21, 113, 24, 771), - Trans(21, 114, 24, 771), - Trans(21, 115, 24, 771), - Trans(22, 5, 24, 771), - Trans(22, 55, 24, 771), - Trans(22, 56, 24, 771), - Trans(22, 57, 24, 771), - Trans(22, 63, 24, 771), - Trans(22, 64, 24, 771), - Trans(22, 68, 24, 771), - Trans(22, 69, 24, 771), - Trans(22, 95, 24, 771), - Trans(22, 96, 24, 771), - Trans(22, 97, 24, 771), - Trans(22, 98, 24, 771), - Trans(22, 99, 24, 771), - Trans(22, 109, 24, 771), - Trans(22, 110, 24, 771), - Trans(22, 114, 24, 771), - Trans(22, 115, 24, 771), - Trans(23, 5, 24, 771), - Trans(23, 6, 24, 771), - Trans(23, 7, 24, 771), - Trans(23, 8, 24, 771), - Trans(23, 9, 24, 771), - Trans(23, 10, 24, 771), - Trans(23, 11, 24, 771), - Trans(23, 15, 24, 771), - Trans(23, 18, 24, 771), - Trans(23, 24, 24, 771), - Trans(23, 25, 24, 771), - Trans(23, 26, 24, 771), - Trans(23, 27, 24, 771), - Trans(23, 39, 24, 771), - Trans(23, 40, 24, 771), - Trans(23, 42, 24, 771), - Trans(23, 54, 24, 771), - Trans(23, 71, 24, 771), - Trans(23, 77, 24, 771), - Trans(23, 84, 24, 771), - Trans(23, 87, 24, 771), - Trans(23, 89, 24, 771), - Trans(23, 106, 24, 771), - Trans(23, 114, 24, 771), - Trans(23, 115, 24, 771), - Trans(25, 5, 24, 771), - Trans(25, 12, 24, 771), - Trans(25, 14, 24, 771), - Trans(25, 15, 24, 771), - Trans(25, 16, 24, 771), - Trans(25, 17, 24, 771), - Trans(25, 18, 24, 771), - Trans(25, 19, 24, 771), - Trans(25, 20, 24, 771), - Trans(25, 21, 24, 771), - Trans(25, 22, 24, 771), - Trans(25, 23, 24, 771), - Trans(25, 24, 24, 771), - Trans(25, 25, 24, 771), - Trans(25, 26, 24, 771), - Trans(25, 30, 24, 771), - Trans(25, 31, 24, 771), - Trans(25, 32, 24, 771), - Trans(25, 33, 24, 771), - Trans(25, 34, 24, 771), - Trans(25, 35, 24, 771), - Trans(25, 36, 24, 771), - Trans(25, 37, 24, 771), - Trans(25, 38, 24, 771), - Trans(25, 40, 24, 771), - Trans(25, 41, 24, 771), - Trans(25, 42, 24, 771), - Trans(25, 43, 24, 771), - Trans(25, 44, 24, 771), - Trans(25, 45, 24, 771), - Trans(25, 46, 24, 771), - Trans(25, 47, 24, 771), - Trans(25, 48, 24, 771), - Trans(25, 52, 24, 771), - Trans(25, 80, 24, 771), - Trans(25, 94, 24, 771), - Trans(25, 103, 24, 771), + Trans(7, 81, 9, -1), + Trans(7, 96, 9, -1), + Trans(7, 105, 23, -1), + Trans(8, 12, 24, 779), + Trans(8, 14, 24, 779), + Trans(8, 15, 24, 779), + Trans(8, 16, 24, 779), + Trans(8, 17, 24, 779), + Trans(8, 18, 24, 779), + Trans(8, 19, 24, 779), + Trans(8, 20, 24, 779), + Trans(8, 21, 24, 779), + Trans(8, 22, 24, 779), + Trans(8, 23, 24, 779), + Trans(8, 24, 24, 779), + Trans(8, 25, 24, 779), + Trans(8, 26, 24, 779), + Trans(8, 30, 24, 779), + Trans(8, 31, 24, 779), + Trans(8, 32, 24, 779), + Trans(8, 33, 24, 779), + Trans(8, 34, 24, 779), + Trans(8, 35, 24, 779), + Trans(8, 36, 24, 779), + Trans(8, 37, 24, 779), + Trans(8, 38, 24, 779), + Trans(8, 40, 24, 779), + Trans(8, 41, 24, 779), + Trans(8, 42, 24, 779), + Trans(8, 43, 24, 779), + Trans(8, 44, 24, 779), + Trans(8, 45, 24, 779), + Trans(8, 46, 24, 779), + Trans(8, 47, 24, 779), + Trans(8, 48, 24, 779), + Trans(8, 52, 24, 779), + Trans(8, 81, 24, 779), + Trans(8, 96, 24, 779), + Trans(8, 105, 24, 779), + Trans(9, 5, 24, 779), + Trans(9, 6, 24, 779), + Trans(9, 7, 24, 779), + Trans(9, 8, 24, 779), + Trans(9, 9, 24, 779), + Trans(9, 10, 24, 779), + Trans(9, 11, 24, 779), + Trans(9, 18, 24, 779), + Trans(9, 24, 24, 779), + Trans(9, 25, 24, 779), + Trans(9, 26, 24, 779), + Trans(9, 27, 24, 779), + Trans(9, 39, 24, 779), + Trans(9, 40, 24, 779), + Trans(9, 42, 24, 779), + Trans(9, 54, 24, 779), + Trans(9, 72, 24, 779), + Trans(9, 78, 24, 779), + Trans(9, 85, 24, 779), + Trans(9, 88, 24, 779), + Trans(9, 90, 24, 779), + Trans(9, 108, 24, 779), + Trans(9, 116, 24, 779), + Trans(9, 117, 24, 779), + Trans(10, 5, 24, 779), + Trans(10, 48, 24, 779), + Trans(10, 117, 24, 779), + Trans(11, 5, 24, 779), + Trans(11, 6, 24, 779), + Trans(11, 7, 24, 779), + Trans(11, 8, 24, 779), + Trans(11, 9, 24, 779), + Trans(11, 10, 24, 779), + Trans(11, 11, 24, 779), + Trans(11, 18, 24, 779), + Trans(11, 24, 24, 779), + Trans(11, 25, 24, 779), + Trans(11, 26, 24, 779), + Trans(11, 27, 24, 779), + Trans(11, 39, 24, 779), + Trans(11, 40, 24, 779), + Trans(11, 42, 24, 779), + Trans(11, 54, 24, 779), + Trans(11, 67, 24, 779), + Trans(11, 71, 24, 779), + Trans(11, 72, 24, 779), + Trans(11, 78, 24, 779), + Trans(11, 82, 24, 779), + Trans(11, 85, 24, 779), + Trans(11, 88, 24, 779), + Trans(11, 90, 24, 779), + Trans(11, 102, 24, 779), + Trans(11, 103, 24, 779), + Trans(11, 108, 24, 779), + Trans(11, 116, 24, 779), + Trans(11, 117, 24, 779), + Trans(12, 5, 24, 779), + Trans(12, 6, 24, 779), + Trans(12, 7, 24, 779), + Trans(12, 8, 24, 779), + Trans(12, 9, 24, 779), + Trans(12, 10, 24, 779), + Trans(12, 11, 24, 779), + Trans(12, 18, 24, 779), + Trans(12, 24, 24, 779), + Trans(12, 25, 24, 779), + Trans(12, 26, 24, 779), + Trans(12, 27, 24, 779), + Trans(12, 37, 24, 779), + Trans(12, 39, 24, 779), + Trans(12, 40, 24, 779), + Trans(12, 42, 24, 779), + Trans(12, 43, 24, 779), + Trans(12, 44, 24, 779), + Trans(12, 46, 24, 779), + Trans(12, 54, 24, 779), + Trans(12, 59, 24, 779), + Trans(12, 72, 24, 779), + Trans(12, 78, 24, 779), + Trans(12, 83, 24, 779), + Trans(12, 85, 24, 779), + Trans(12, 88, 24, 779), + Trans(12, 90, 24, 779), + Trans(12, 92, 24, 779), + Trans(12, 108, 24, 779), + Trans(12, 116, 24, 779), + Trans(12, 117, 24, 779), + Trans(13, 5, 24, 779), + Trans(13, 117, 24, 779), + Trans(14, 5, 24, 779), + Trans(14, 42, 24, 779), + Trans(15, 5, 24, 779), + Trans(15, 6, 24, 779), + Trans(15, 7, 24, 779), + Trans(15, 8, 24, 779), + Trans(15, 9, 24, 779), + Trans(15, 10, 24, 779), + Trans(15, 11, 24, 779), + Trans(15, 18, 24, 779), + Trans(15, 24, 24, 779), + Trans(15, 25, 24, 779), + Trans(15, 26, 24, 779), + Trans(15, 27, 24, 779), + Trans(15, 31, 24, 779), + Trans(15, 37, 24, 779), + Trans(15, 39, 24, 779), + Trans(15, 40, 24, 779), + Trans(15, 42, 24, 779), + Trans(15, 44, 24, 779), + Trans(15, 49, 24, 779), + Trans(15, 50, 24, 779), + Trans(15, 51, 24, 779), + Trans(15, 54, 24, 779), + Trans(15, 59, 24, 779), + Trans(15, 62, 24, 779), + Trans(15, 66, 24, 779), + Trans(15, 67, 24, 779), + Trans(15, 68, 24, 779), + Trans(15, 71, 24, 779), + Trans(15, 72, 24, 779), + Trans(15, 73, 24, 779), + Trans(15, 75, 24, 779), + Trans(15, 78, 24, 779), + Trans(15, 79, 24, 779), + Trans(15, 82, 24, 779), + Trans(15, 83, 24, 779), + Trans(15, 85, 24, 779), + Trans(15, 86, 24, 779), + Trans(15, 88, 24, 779), + Trans(15, 90, 24, 779), + Trans(15, 102, 24, 779), + Trans(15, 103, 24, 779), + Trans(15, 107, 24, 779), + Trans(15, 108, 24, 779), + Trans(15, 110, 24, 779), + Trans(15, 113, 24, 779), + Trans(15, 114, 24, 779), + Trans(15, 115, 24, 779), + Trans(15, 116, 24, 779), + Trans(15, 117, 24, 779), + Trans(16, 5, 24, 779), + Trans(16, 6, 24, 779), + Trans(16, 7, 24, 779), + Trans(16, 8, 24, 779), + Trans(16, 9, 24, 779), + Trans(16, 10, 24, 779), + Trans(16, 11, 24, 779), + Trans(16, 18, 24, 779), + Trans(16, 24, 24, 779), + Trans(16, 25, 24, 779), + Trans(16, 26, 24, 779), + Trans(16, 27, 24, 779), + Trans(16, 37, 24, 779), + Trans(16, 39, 24, 779), + Trans(16, 40, 24, 779), + Trans(16, 42, 24, 779), + Trans(16, 46, 24, 779), + Trans(16, 54, 24, 779), + Trans(16, 72, 24, 779), + Trans(16, 78, 24, 779), + Trans(16, 85, 24, 779), + Trans(16, 88, 24, 779), + Trans(16, 90, 24, 779), + Trans(16, 108, 24, 779), + Trans(16, 116, 24, 779), + Trans(16, 117, 24, 779), + Trans(17, 5, 24, 779), + Trans(17, 12, 24, 779), + Trans(17, 13, 24, 779), + Trans(17, 14, 24, 779), + Trans(17, 15, 24, 779), + Trans(17, 16, 24, 779), + Trans(17, 17, 24, 779), + Trans(17, 18, 24, 779), + Trans(17, 19, 24, 779), + Trans(17, 20, 24, 779), + Trans(17, 21, 24, 779), + Trans(17, 22, 24, 779), + Trans(17, 23, 24, 779), + Trans(17, 24, 24, 779), + Trans(17, 25, 24, 779), + Trans(17, 26, 24, 779), + Trans(17, 30, 24, 779), + Trans(17, 31, 24, 779), + Trans(17, 32, 24, 779), + Trans(17, 33, 24, 779), + Trans(17, 34, 24, 779), + Trans(17, 35, 24, 779), + Trans(17, 36, 24, 779), + Trans(17, 37, 24, 779), + Trans(17, 38, 24, 779), + Trans(17, 40, 24, 779), + Trans(17, 41, 24, 779), + Trans(17, 42, 24, 779), + Trans(17, 43, 24, 779), + Trans(17, 44, 24, 779), + Trans(17, 45, 24, 779), + Trans(17, 46, 24, 779), + Trans(17, 47, 24, 779), + Trans(17, 48, 24, 779), + Trans(17, 52, 24, 779), + Trans(17, 67, 24, 779), + Trans(17, 81, 24, 779), + Trans(17, 96, 24, 779), + Trans(17, 105, 24, 779), + Trans(18, 5, 24, 779), + Trans(18, 12, 24, 779), + Trans(18, 14, 24, 779), + Trans(18, 16, 24, 779), + Trans(18, 17, 24, 779), + Trans(18, 18, 24, 779), + Trans(18, 19, 24, 779), + Trans(18, 20, 24, 779), + Trans(18, 21, 24, 779), + Trans(18, 22, 24, 779), + Trans(18, 23, 24, 779), + Trans(18, 24, 24, 779), + Trans(18, 25, 24, 779), + Trans(18, 26, 24, 779), + Trans(18, 31, 24, 779), + Trans(18, 32, 24, 779), + Trans(18, 33, 24, 779), + Trans(18, 34, 24, 779), + Trans(18, 37, 24, 779), + Trans(18, 40, 24, 779), + Trans(18, 43, 24, 779), + Trans(18, 44, 24, 779), + Trans(18, 45, 24, 779), + Trans(18, 46, 24, 779), + Trans(18, 47, 24, 779), + Trans(18, 48, 24, 779), + Trans(18, 49, 24, 779), + Trans(18, 50, 24, 779), + Trans(18, 51, 24, 779), + Trans(18, 52, 24, 779), + Trans(18, 60, 24, 779), + Trans(18, 62, 24, 779), + Trans(18, 63, 24, 779), + Trans(18, 66, 24, 779), + Trans(18, 67, 24, 779), + Trans(18, 68, 24, 779), + Trans(18, 72, 24, 779), + Trans(18, 73, 24, 779), + Trans(18, 75, 24, 779), + Trans(18, 79, 24, 779), + Trans(18, 82, 24, 779), + Trans(18, 83, 24, 779), + Trans(18, 86, 24, 779), + Trans(18, 96, 24, 779), + Trans(18, 105, 24, 779), + Trans(18, 107, 24, 779), + Trans(18, 110, 24, 779), + Trans(18, 113, 24, 779), + Trans(18, 114, 24, 779), + Trans(18, 115, 24, 779), + Trans(19, 5, 24, 779), + Trans(19, 12, 24, 779), + Trans(19, 14, 24, 779), + Trans(19, 15, 24, 779), + Trans(19, 16, 24, 779), + Trans(19, 17, 24, 779), + Trans(19, 18, 24, 779), + Trans(19, 19, 24, 779), + Trans(19, 20, 24, 779), + Trans(19, 21, 24, 779), + Trans(19, 22, 24, 779), + Trans(19, 23, 24, 779), + Trans(19, 24, 24, 779), + Trans(19, 25, 24, 779), + Trans(19, 26, 24, 779), + Trans(19, 31, 24, 779), + Trans(19, 32, 24, 779), + Trans(19, 33, 24, 779), + Trans(19, 34, 24, 779), + Trans(19, 35, 24, 779), + Trans(19, 36, 24, 779), + Trans(19, 37, 24, 779), + Trans(19, 40, 24, 779), + Trans(19, 41, 24, 779), + Trans(19, 42, 24, 779), + Trans(19, 43, 24, 779), + Trans(19, 44, 24, 779), + Trans(19, 45, 24, 779), + Trans(19, 46, 24, 779), + Trans(19, 47, 24, 779), + Trans(19, 48, 24, 779), + Trans(19, 52, 24, 779), + Trans(19, 96, 24, 779), + Trans(19, 105, 24, 779), + Trans(20, 5, 24, 779), + Trans(20, 12, 24, 779), + Trans(20, 13, 24, 779), + Trans(20, 14, 24, 779), + Trans(20, 16, 24, 779), + Trans(20, 17, 24, 779), + Trans(20, 18, 24, 779), + Trans(20, 19, 24, 779), + Trans(20, 20, 24, 779), + Trans(20, 21, 24, 779), + Trans(20, 22, 24, 779), + Trans(20, 23, 24, 779), + Trans(20, 24, 24, 779), + Trans(20, 25, 24, 779), + Trans(20, 26, 24, 779), + Trans(20, 31, 24, 779), + Trans(20, 32, 24, 779), + Trans(20, 33, 24, 779), + Trans(20, 34, 24, 779), + Trans(20, 40, 24, 779), + Trans(20, 42, 24, 779), + Trans(20, 43, 24, 779), + Trans(20, 44, 24, 779), + Trans(20, 45, 24, 779), + Trans(20, 46, 24, 779), + Trans(20, 47, 24, 779), + Trans(20, 48, 24, 779), + Trans(20, 52, 24, 779), + Trans(20, 96, 24, 779), + Trans(20, 105, 24, 779), + Trans(21, 0, 24, 779), + Trans(21, 5, 24, 779), + Trans(21, 6, 24, 779), + Trans(21, 7, 24, 779), + Trans(21, 8, 24, 779), + Trans(21, 9, 24, 779), + Trans(21, 10, 24, 779), + Trans(21, 11, 24, 779), + Trans(21, 18, 24, 779), + Trans(21, 24, 24, 779), + Trans(21, 25, 24, 779), + Trans(21, 26, 24, 779), + Trans(21, 27, 24, 779), + Trans(21, 31, 24, 779), + Trans(21, 37, 24, 779), + Trans(21, 39, 24, 779), + Trans(21, 40, 24, 779), + Trans(21, 42, 24, 779), + Trans(21, 44, 24, 779), + Trans(21, 49, 24, 779), + Trans(21, 50, 24, 779), + Trans(21, 51, 24, 779), + Trans(21, 54, 24, 779), + Trans(21, 59, 24, 779), + Trans(21, 61, 24, 779), + Trans(21, 62, 24, 779), + Trans(21, 63, 24, 779), + Trans(21, 66, 24, 779), + Trans(21, 67, 24, 779), + Trans(21, 68, 24, 779), + Trans(21, 71, 24, 779), + Trans(21, 72, 24, 779), + Trans(21, 73, 24, 779), + Trans(21, 74, 24, 779), + Trans(21, 75, 24, 779), + Trans(21, 78, 24, 779), + Trans(21, 79, 24, 779), + Trans(21, 80, 24, 779), + Trans(21, 82, 24, 779), + Trans(21, 83, 24, 779), + Trans(21, 85, 24, 779), + Trans(21, 86, 24, 779), + Trans(21, 87, 24, 779), + Trans(21, 88, 24, 779), + Trans(21, 90, 24, 779), + Trans(21, 91, 24, 779), + Trans(21, 93, 24, 779), + Trans(21, 94, 24, 779), + Trans(21, 102, 24, 779), + Trans(21, 103, 24, 779), + Trans(21, 107, 24, 779), + Trans(21, 108, 24, 779), + Trans(21, 110, 24, 779), + Trans(21, 113, 24, 779), + Trans(21, 114, 24, 779), + Trans(21, 115, 24, 779), + Trans(21, 116, 24, 779), + Trans(21, 117, 24, 779), + Trans(22, 5, 24, 779), + Trans(22, 55, 24, 779), + Trans(22, 56, 24, 779), + Trans(22, 57, 24, 779), + Trans(22, 64, 24, 779), + Trans(22, 65, 24, 779), + Trans(22, 69, 24, 779), + Trans(22, 70, 24, 779), + Trans(22, 97, 24, 779), + Trans(22, 98, 24, 779), + Trans(22, 99, 24, 779), + Trans(22, 100, 24, 779), + Trans(22, 101, 24, 779), + Trans(22, 111, 24, 779), + Trans(22, 112, 24, 779), + Trans(22, 116, 24, 779), + Trans(22, 117, 24, 779), + Trans(23, 5, 24, 779), + Trans(23, 6, 24, 779), + Trans(23, 7, 24, 779), + Trans(23, 8, 24, 779), + Trans(23, 9, 24, 779), + Trans(23, 10, 24, 779), + Trans(23, 11, 24, 779), + Trans(23, 15, 24, 779), + Trans(23, 18, 24, 779), + Trans(23, 24, 24, 779), + Trans(23, 25, 24, 779), + Trans(23, 26, 24, 779), + Trans(23, 27, 24, 779), + Trans(23, 39, 24, 779), + Trans(23, 40, 24, 779), + Trans(23, 42, 24, 779), + Trans(23, 54, 24, 779), + Trans(23, 72, 24, 779), + Trans(23, 78, 24, 779), + Trans(23, 85, 24, 779), + Trans(23, 88, 24, 779), + Trans(23, 90, 24, 779), + Trans(23, 108, 24, 779), + Trans(23, 116, 24, 779), + Trans(23, 117, 24, 779), + Trans(25, 5, 24, 779), + Trans(25, 12, 24, 779), + Trans(25, 14, 24, 779), + Trans(25, 15, 24, 779), + Trans(25, 16, 24, 779), + Trans(25, 17, 24, 779), + Trans(25, 18, 24, 779), + Trans(25, 19, 24, 779), + Trans(25, 20, 24, 779), + Trans(25, 21, 24, 779), + Trans(25, 22, 24, 779), + Trans(25, 23, 24, 779), + Trans(25, 24, 24, 779), + Trans(25, 25, 24, 779), + Trans(25, 26, 24, 779), + Trans(25, 30, 24, 779), + Trans(25, 31, 24, 779), + Trans(25, 32, 24, 779), + Trans(25, 33, 24, 779), + Trans(25, 34, 24, 779), + Trans(25, 35, 24, 779), + Trans(25, 36, 24, 779), + Trans(25, 37, 24, 779), + Trans(25, 38, 24, 779), + Trans(25, 40, 24, 779), + Trans(25, 41, 24, 779), + Trans(25, 42, 24, 779), + Trans(25, 43, 24, 779), + Trans(25, 44, 24, 779), + Trans(25, 45, 24, 779), + Trans(25, 46, 24, 779), + Trans(25, 47, 24, 779), + Trans(25, 48, 24, 779), + Trans(25, 52, 24, 779), + Trans(25, 81, 24, 779), + Trans(25, 96, 24, 779), + Trans(25, 105, 24, 779), ], k: 3, }, - /* 652 - "WithGenericArgumentListOpt" */ + /* 663 - "WithGenericArgumentListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 772), Trans(0, 43, 2, 773)], + transitions: &[Trans(0, 32, 1, 780), Trans(0, 43, 2, 781)], k: 1, }, - /* 653 - "WithGenericArgumentOpt" */ + /* 664 - "WithGenericArgumentOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 7, 1, 767), - Trans(0, 8, 1, 767), - Trans(0, 9, 1, 767), - Trans(0, 10, 1, 767), - Trans(0, 11, 1, 767), - Trans(0, 43, 2, 768), - Trans(0, 114, 1, 767), - Trans(0, 115, 1, 767), + Trans(0, 7, 1, 775), + Trans(0, 8, 1, 775), + Trans(0, 9, 1, 775), + Trans(0, 10, 1, 775), + Trans(0, 11, 1, 775), + Trans(0, 43, 2, 776), + Trans(0, 116, 1, 775), + Trans(0, 117, 1, 775), ], k: 1, }, - /* 654 - "WithGenericParameter" */ + /* 665 - "WithGenericParameter" */ LookaheadDFA { - prod0: 757, + prod0: 765, transitions: &[], k: 0, }, - /* 655 - "WithGenericParameterItem" */ + /* 666 - "WithGenericParameterItem" */ LookaheadDFA { - prod0: 763, + prod0: 771, transitions: &[], k: 0, }, - /* 656 - "WithGenericParameterItemOpt" */ + /* 667 - "WithGenericParameterItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 2, 765), - Trans(0, 36, 1, 764), - Trans(0, 43, 2, 765), + Trans(0, 32, 2, 773), + Trans(0, 36, 1, 772), + Trans(0, 43, 2, 773), ], k: 1, }, - /* 657 - "WithGenericParameterList" */ + /* 668 - "WithGenericParameterList" */ LookaheadDFA { - prod0: 758, + prod0: 766, transitions: &[], k: 0, }, - /* 658 - "WithGenericParameterListList" */ + /* 669 - "WithGenericParameterListList" */ LookaheadDFA { prod0: -1, transitions: &[ Trans(0, 32, 1, -1), Trans(0, 43, 5, -1), Trans(1, 5, 4, -1), - Trans(1, 43, 12, -1), - Trans(1, 115, 2, -1), - Trans(2, 5, 3, 759), - Trans(2, 32, 3, 759), - Trans(2, 36, 3, 759), - Trans(2, 43, 3, 759), - Trans(4, 43, 11, 760), - Trans(4, 115, 3, 759), + Trans(1, 43, 13, -1), + Trans(1, 117, 2, -1), + Trans(2, 5, 3, 767), + Trans(2, 31, 3, 767), + Trans(4, 43, 12, 768), + Trans(4, 117, 3, 767), Trans(5, 5, 6, -1), Trans(5, 13, 7, -1), Trans(5, 37, 8, -1), Trans(5, 40, 9, -1), Trans(5, 42, 10, -1), - Trans(6, 13, 11, 760), - Trans(6, 37, 11, 760), - Trans(6, 40, 11, 760), - Trans(6, 42, 11, 760), - Trans(7, 5, 11, 760), - Trans(7, 53, 11, 760), - Trans(7, 55, 11, 760), - Trans(7, 56, 11, 760), - Trans(7, 57, 11, 760), - Trans(7, 63, 11, 760), - Trans(7, 64, 11, 760), - Trans(7, 68, 11, 760), - Trans(7, 69, 11, 760), - Trans(7, 83, 11, 760), - Trans(7, 95, 11, 760), - Trans(7, 96, 11, 760), - Trans(7, 97, 11, 760), - Trans(7, 98, 11, 760), - Trans(7, 99, 11, 760), - Trans(7, 102, 11, 760), - Trans(7, 104, 11, 760), - Trans(7, 107, 11, 760), - Trans(7, 109, 11, 760), - Trans(7, 110, 11, 760), - Trans(7, 114, 11, 760), - Trans(7, 115, 11, 760), - Trans(8, 5, 11, 760), - Trans(8, 42, 11, 760), - Trans(9, 5, 11, 760), - Trans(9, 31, 11, 760), - Trans(9, 37, 11, 760), - Trans(9, 40, 11, 760), - Trans(9, 44, 11, 760), - Trans(9, 49, 11, 760), - Trans(9, 50, 11, 760), - Trans(9, 51, 11, 760), - Trans(9, 54, 11, 760), - Trans(9, 61, 11, 760), - Trans(9, 62, 11, 760), - Trans(9, 65, 11, 760), - Trans(9, 66, 11, 760), - Trans(9, 67, 11, 760), - Trans(9, 70, 11, 760), - Trans(9, 71, 11, 760), - Trans(9, 72, 11, 760), - Trans(9, 74, 11, 760), - Trans(9, 78, 11, 760), - Trans(9, 81, 11, 760), - Trans(9, 82, 11, 760), - Trans(9, 85, 11, 760), - Trans(9, 100, 11, 760), - Trans(9, 101, 11, 760), - Trans(9, 105, 11, 760), - Trans(9, 106, 11, 760), - Trans(9, 108, 11, 760), - Trans(9, 111, 11, 760), - Trans(9, 112, 11, 760), - Trans(9, 113, 11, 760), - Trans(9, 114, 11, 760), - Trans(9, 115, 11, 760), - Trans(10, 5, 11, 760), - Trans(10, 37, 11, 760), - Trans(10, 40, 11, 760), - Trans(10, 46, 11, 760), - Trans(10, 115, 11, 760), - Trans(12, 5, 11, 760), - Trans(12, 13, 11, 760), - Trans(12, 37, 11, 760), - Trans(12, 40, 11, 760), - Trans(12, 42, 11, 760), + Trans(5, 67, 11, -1), + Trans(6, 13, 12, 768), + Trans(6, 37, 12, 768), + Trans(6, 40, 12, 768), + Trans(6, 42, 12, 768), + Trans(6, 67, 12, 768), + Trans(7, 5, 12, 768), + Trans(7, 53, 12, 768), + Trans(7, 55, 12, 768), + Trans(7, 56, 12, 768), + Trans(7, 57, 12, 768), + Trans(7, 64, 12, 768), + Trans(7, 65, 12, 768), + Trans(7, 69, 12, 768), + Trans(7, 70, 12, 768), + Trans(7, 84, 12, 768), + Trans(7, 97, 12, 768), + Trans(7, 98, 12, 768), + Trans(7, 99, 12, 768), + Trans(7, 100, 12, 768), + Trans(7, 101, 12, 768), + Trans(7, 104, 12, 768), + Trans(7, 106, 12, 768), + Trans(7, 109, 12, 768), + Trans(7, 111, 12, 768), + Trans(7, 112, 12, 768), + Trans(7, 116, 12, 768), + Trans(7, 117, 12, 768), + Trans(8, 5, 12, 768), + Trans(8, 42, 12, 768), + Trans(9, 5, 12, 768), + Trans(9, 31, 12, 768), + Trans(9, 37, 12, 768), + Trans(9, 40, 12, 768), + Trans(9, 44, 12, 768), + Trans(9, 49, 12, 768), + Trans(9, 50, 12, 768), + Trans(9, 51, 12, 768), + Trans(9, 54, 12, 768), + Trans(9, 62, 12, 768), + Trans(9, 63, 12, 768), + Trans(9, 66, 12, 768), + Trans(9, 67, 12, 768), + Trans(9, 68, 12, 768), + Trans(9, 71, 12, 768), + Trans(9, 72, 12, 768), + Trans(9, 73, 12, 768), + Trans(9, 75, 12, 768), + Trans(9, 79, 12, 768), + Trans(9, 82, 12, 768), + Trans(9, 83, 12, 768), + Trans(9, 86, 12, 768), + Trans(9, 102, 12, 768), + Trans(9, 103, 12, 768), + Trans(9, 107, 12, 768), + Trans(9, 108, 12, 768), + Trans(9, 110, 12, 768), + Trans(9, 113, 12, 768), + Trans(9, 114, 12, 768), + Trans(9, 115, 12, 768), + Trans(9, 116, 12, 768), + Trans(9, 117, 12, 768), + Trans(10, 5, 12, 768), + Trans(10, 37, 12, 768), + Trans(10, 40, 12, 768), + Trans(10, 46, 12, 768), + Trans(10, 117, 12, 768), + Trans(11, 5, 12, 768), + Trans(11, 116, 12, 768), + Trans(11, 117, 12, 768), + Trans(13, 5, 12, 768), + Trans(13, 13, 12, 768), + Trans(13, 37, 12, 768), + Trans(13, 40, 12, 768), + Trans(13, 42, 12, 768), + Trans(13, 67, 12, 768), ], k: 3, }, - /* 659 - "WithGenericParameterListOpt" */ + /* 670 - "WithGenericParameterListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 32, 1, 761), Trans(0, 43, 2, 762)], + transitions: &[Trans(0, 32, 1, 769), Trans(0, 43, 2, 770)], k: 1, }, - /* 660 - "WithParameter" */ + /* 671 - "WithParameter" */ LookaheadDFA { - prod0: 739, + prod0: 744, transitions: &[], k: 0, }, - /* 661 - "WithParameterGroup" */ + /* 672 - "WithParameterGroup" */ LookaheadDFA { - prod0: 747, + prod0: 752, transitions: &[], k: 0, }, - /* 662 - "WithParameterGroupGroup" */ + /* 673 - "WithParameterGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 40, 1, 748), - Trans(0, 82, 2, 749), - Trans(0, 91, 2, 749), + Trans(0, 40, 1, 753), + Trans(0, 83, 2, 754), + Trans(0, 92, 2, 754), ], k: 1, }, - /* 663 - "WithParameterGroupList" */ + /* 674 - "WithParameterGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 750), - Trans(0, 40, 2, 751), - Trans(0, 82, 2, 751), - Trans(0, 91, 2, 751), + Trans(0, 37, 1, 755), + Trans(0, 40, 2, 756), + Trans(0, 83, 2, 756), + Trans(0, 92, 2, 756), ], k: 1, }, - /* 664 - "WithParameterItem" */ + /* 675 - "WithParameterItem" */ LookaheadDFA { - prod0: 752, + prod0: 757, transitions: &[], k: 0, }, - /* 665 - "WithParameterItemGroup" */ + /* 676 - "WithParameterItemGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 82, 2, 756), Trans(0, 91, 1, 755)], + transitions: &[Trans(0, 83, 2, 761), Trans(0, 92, 1, 760)], k: 1, }, - /* 666 - "WithParameterItemGroup0" */ + /* 677 - "WithParameterItemGroup0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 53, 1, 753), - Trans(0, 55, 1, 753), - Trans(0, 56, 1, 753), - Trans(0, 57, 1, 753), - Trans(0, 63, 1, 753), - Trans(0, 64, 1, 753), - Trans(0, 68, 1, 753), - Trans(0, 69, 1, 753), - Trans(0, 83, 1, 753), - Trans(0, 95, 1, 753), - Trans(0, 96, 1, 753), - Trans(0, 97, 1, 753), - Trans(0, 98, 1, 753), - Trans(0, 99, 1, 753), - Trans(0, 102, 1, 753), - Trans(0, 104, 1, 753), - Trans(0, 107, 1, 753), - Trans(0, 108, 2, 754), - Trans(0, 109, 1, 753), - Trans(0, 110, 1, 753), - Trans(0, 114, 1, 753), - Trans(0, 115, 1, 753), + Trans(0, 53, 1, 758), + Trans(0, 55, 1, 758), + Trans(0, 56, 1, 758), + Trans(0, 57, 1, 758), + Trans(0, 64, 1, 758), + Trans(0, 65, 1, 758), + Trans(0, 69, 1, 758), + Trans(0, 70, 1, 758), + Trans(0, 84, 1, 758), + Trans(0, 97, 1, 758), + Trans(0, 98, 1, 758), + Trans(0, 99, 1, 758), + Trans(0, 100, 1, 758), + Trans(0, 101, 1, 758), + Trans(0, 104, 1, 758), + Trans(0, 106, 1, 758), + Trans(0, 109, 1, 758), + Trans(0, 110, 2, 759), + Trans(0, 111, 1, 758), + Trans(0, 112, 1, 758), + Trans(0, 116, 1, 758), + Trans(0, 117, 1, 758), ], k: 1, }, - /* 667 - "WithParameterList" */ + /* 678 - "WithParameterList" */ LookaheadDFA { - prod0: 742, + prod0: 747, transitions: &[], k: 0, }, - /* 668 - "WithParameterListList" */ + /* 679 - "WithParameterListList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -17565,108 +17713,124 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 671] = &[ Trans(1, 5, 6, -1), Trans(1, 37, 2, -1), Trans(1, 40, 4, -1), - Trans(1, 44, 11, -1), - Trans(1, 46, 12, -1), - Trans(1, 82, 5, -1), - Trans(1, 91, 5, -1), - Trans(2, 5, 3, 743), - Trans(2, 41, 3, 743), - Trans(4, 5, 3, 743), - Trans(4, 37, 3, 743), - Trans(4, 40, 3, 743), - Trans(4, 82, 3, 743), - Trans(4, 91, 3, 743), - Trans(5, 5, 3, 743), - Trans(5, 115, 3, 743), - Trans(6, 37, 3, 743), - Trans(6, 40, 3, 743), - Trans(6, 44, 13, 744), - Trans(6, 46, 13, 744), - Trans(6, 82, 3, 743), - Trans(6, 91, 3, 743), - Trans(7, 5, 9, -1), - Trans(7, 32, 10, -1), - Trans(7, 44, 11, -1), - Trans(7, 46, 12, -1), - Trans(8, 5, 14, -1), - Trans(8, 40, 15, -1), - Trans(8, 42, 16, -1), - Trans(9, 32, 13, 744), - Trans(9, 44, 13, 744), - Trans(9, 46, 13, 744), - Trans(10, 5, 13, 744), - Trans(10, 37, 13, 744), - Trans(10, 40, 13, 744), - Trans(10, 44, 13, 744), - Trans(10, 46, 13, 744), - Trans(10, 82, 13, 744), - Trans(10, 91, 13, 744), - Trans(11, 5, 13, 744), - Trans(11, 32, 13, 744), - Trans(11, 44, 13, 744), - Trans(11, 46, 13, 744), - Trans(12, 5, 13, 744), - Trans(12, 40, 13, 744), - Trans(12, 42, 13, 744), - Trans(14, 40, 13, 744), - Trans(14, 42, 13, 744), - Trans(15, 5, 13, 744), - Trans(15, 31, 13, 744), - Trans(15, 37, 13, 744), - Trans(15, 40, 13, 744), - Trans(15, 44, 13, 744), - Trans(15, 49, 13, 744), - Trans(15, 50, 13, 744), - Trans(15, 51, 13, 744), - Trans(15, 61, 13, 744), - Trans(15, 65, 13, 744), - Trans(15, 66, 13, 744), - Trans(15, 67, 13, 744), - Trans(15, 71, 13, 744), - Trans(15, 72, 13, 744), - Trans(15, 74, 13, 744), - Trans(15, 78, 13, 744), - Trans(15, 81, 13, 744), - Trans(15, 82, 13, 744), - Trans(15, 85, 13, 744), - Trans(15, 105, 13, 744), - Trans(15, 108, 13, 744), - Trans(15, 111, 13, 744), - Trans(15, 112, 13, 744), - Trans(15, 113, 13, 744), - Trans(16, 5, 13, 744), - Trans(16, 37, 13, 744), - Trans(16, 40, 13, 744), - Trans(16, 46, 13, 744), - Trans(16, 115, 13, 744), + Trans(1, 44, 16, -1), + Trans(1, 46, 17, -1), + Trans(1, 83, 5, -1), + Trans(1, 92, 5, -1), + Trans(2, 5, 3, 748), + Trans(2, 41, 3, 748), + Trans(4, 5, 3, 748), + Trans(4, 37, 3, 748), + Trans(4, 40, 3, 748), + Trans(4, 83, 3, 748), + Trans(4, 92, 3, 748), + Trans(5, 5, 3, 748), + Trans(5, 117, 3, 748), + Trans(6, 37, 3, 748), + Trans(6, 40, 3, 748), + Trans(6, 44, 13, 749), + Trans(6, 46, 13, 749), + Trans(6, 83, 3, 748), + Trans(6, 92, 3, 748), + Trans(7, 5, 14, -1), + Trans(7, 32, 15, -1), + Trans(7, 44, 16, -1), + Trans(7, 46, 17, -1), + Trans(8, 5, 9, -1), + Trans(8, 40, 10, -1), + Trans(8, 42, 11, -1), + Trans(8, 47, 12, -1), + Trans(9, 40, 13, 749), + Trans(9, 42, 13, 749), + Trans(9, 47, 13, 749), + Trans(10, 5, 13, 749), + Trans(10, 31, 13, 749), + Trans(10, 37, 13, 749), + Trans(10, 40, 13, 749), + Trans(10, 44, 13, 749), + Trans(10, 49, 13, 749), + Trans(10, 50, 13, 749), + Trans(10, 51, 13, 749), + Trans(10, 62, 13, 749), + Trans(10, 66, 13, 749), + Trans(10, 67, 13, 749), + Trans(10, 68, 13, 749), + Trans(10, 72, 13, 749), + Trans(10, 73, 13, 749), + Trans(10, 75, 13, 749), + Trans(10, 79, 13, 749), + Trans(10, 82, 13, 749), + Trans(10, 83, 13, 749), + Trans(10, 86, 13, 749), + Trans(10, 107, 13, 749), + Trans(10, 110, 13, 749), + Trans(10, 113, 13, 749), + Trans(10, 114, 13, 749), + Trans(10, 115, 13, 749), + Trans(11, 5, 13, 749), + Trans(11, 37, 13, 749), + Trans(11, 40, 13, 749), + Trans(11, 46, 13, 749), + Trans(11, 117, 13, 749), + Trans(12, 0, 13, 749), + Trans(12, 5, 13, 749), + Trans(12, 37, 13, 749), + Trans(12, 40, 13, 749), + Trans(12, 44, 13, 749), + Trans(12, 61, 13, 749), + Trans(12, 73, 13, 749), + Trans(12, 74, 13, 749), + Trans(12, 80, 13, 749), + Trans(12, 87, 13, 749), + Trans(12, 91, 13, 749), + Trans(12, 93, 13, 749), + Trans(12, 94, 13, 749), + Trans(14, 32, 13, 749), + Trans(14, 44, 13, 749), + Trans(14, 46, 13, 749), + Trans(15, 5, 13, 749), + Trans(15, 37, 13, 749), + Trans(15, 40, 13, 749), + Trans(15, 44, 13, 749), + Trans(15, 46, 13, 749), + Trans(15, 83, 13, 749), + Trans(15, 92, 13, 749), + Trans(16, 5, 13, 749), + Trans(16, 32, 13, 749), + Trans(16, 44, 13, 749), + Trans(16, 46, 13, 749), + Trans(17, 5, 13, 749), + Trans(17, 40, 13, 749), + Trans(17, 42, 13, 749), + Trans(17, 47, 13, 749), ], k: 3, }, - /* 669 - "WithParameterListOpt" */ + /* 680 - "WithParameterListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 32, 1, 745), - Trans(0, 44, 2, 746), - Trans(0, 46, 2, 746), + Trans(0, 32, 1, 750), + Trans(0, 44, 2, 751), + Trans(0, 46, 2, 751), ], k: 1, }, - /* 670 - "WithParameterOpt" */ + /* 681 - "WithParameterOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 37, 1, 740), - Trans(0, 40, 1, 740), - Trans(0, 46, 2, 741), - Trans(0, 82, 1, 740), - Trans(0, 91, 1, 740), + Trans(0, 37, 1, 745), + Trans(0, 40, 1, 745), + Trans(0, 46, 2, 746), + Trans(0, 83, 1, 745), + Trans(0, 92, 1, 745), ], k: 1, }, ]; -pub const PRODUCTIONS: &[Production; 976] = &[ +pub const PRODUCTIONS: &[Production; 994] = &[ // 0 - CommentsTerm: "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+"; Production { lhs: 106, @@ -17674,17 +17838,17 @@ pub const PRODUCTIONS: &[Production; 976] = &[ }, // 1 - StringLiteralTerm: "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}"; Production { - lhs: 579, + lhs: 592, production: &[ParseType::T(6)], }, // 2 - ExponentTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/; Production { - lhs: 162, + lhs: 165, production: &[ParseType::T(7)], }, // 3 - FixedPointTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/; Production { - lhs: 217, + lhs: 220, production: &[ParseType::T(8)], }, // 4 - BasedTerm: /(?:[0-9]+(?:_[0-9]+)*)?'s?[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/; @@ -17704,17 +17868,17 @@ pub const PRODUCTIONS: &[Production; 976] = &[ }, // 7 - MinusColonTerm: '-:'; Production { - lhs: 383, + lhs: 387, production: &[ParseType::T(12)], }, // 8 - MinusGTTerm: '->'; Production { - lhs: 386, + lhs: 390, production: &[ParseType::T(13)], }, // 9 - PlusColonTerm: '+:'; Production { - lhs: 483, + lhs: 488, production: &[ParseType::T(14)], }, // 10 - AssignmentOperatorTerm: "\+=|-=|\*=|/=|%=|&=|\|=|\^=|<<=|>>=|<<<=|>>>="; @@ -17724,62 +17888,62 @@ pub const PRODUCTIONS: &[Production; 976] = &[ }, // 11 - Operator11Term: "\*\*"; Production { - lhs: 458, + lhs: 463, production: &[ParseType::T(16)], }, // 12 - Operator10Term: "/|%"; Production { - lhs: 455, + lhs: 460, production: &[ParseType::T(17)], }, // 13 - Operator09Term: "\+|-"; Production { - lhs: 452, + lhs: 457, production: &[ParseType::T(18)], }, // 14 - Operator08Term: "<<<|>>>|<<|>>"; Production { - lhs: 449, + lhs: 454, production: &[ParseType::T(19)], }, // 15 - Operator07Term: "<=|>=|<:|>:"; Production { - lhs: 446, + lhs: 451, production: &[ParseType::T(20)], }, // 16 - Operator06Term: "===|==\?|!==|!=\?|==|!="; Production { - lhs: 443, + lhs: 448, production: &[ParseType::T(21)], }, // 17 - Operator02Term: "&&"; Production { - lhs: 431, + lhs: 436, production: &[ParseType::T(22)], }, // 18 - Operator01Term: "\|\|"; Production { - lhs: 428, + lhs: 433, production: &[ParseType::T(23)], }, // 19 - Operator05Term: "&"; Production { - lhs: 440, + lhs: 445, production: &[ParseType::T(24)], }, // 20 - Operator04Term: "\^~|\^|~\^"; Production { - lhs: 437, + lhs: 442, production: &[ParseType::T(25)], }, // 21 - Operator03Term: "\|"; Production { - lhs: 434, + lhs: 439, production: &[ParseType::T(26)], }, // 22 - UnaryOperatorTerm: "~&|~\||!|~"; Production { - lhs: 626, + lhs: 639, production: &[ParseType::T(27)], }, // 23 - BackQuoteTerm: "`"; @@ -17809,82 +17973,82 @@ pub const PRODUCTIONS: &[Production; 976] = &[ }, // 28 - DotDotEquTerm: '..='; Production { - lhs: 127, + lhs: 130, production: &[ParseType::T(33)], }, // 29 - DotDotTerm: '..'; Production { - lhs: 129, + lhs: 132, production: &[ParseType::T(34)], }, // 30 - DotTerm: '.'; Production { - lhs: 131, + lhs: 134, production: &[ParseType::T(35)], }, // 31 - EquTerm: '='; Production { - lhs: 159, + lhs: 162, production: &[ParseType::T(36)], }, // 32 - HashTerm: '#'; Production { - lhs: 238, + lhs: 242, production: &[ParseType::T(37)], }, // 33 - LAngleTerm: '<'; Production { - lhs: 353, + lhs: 357, production: &[ParseType::T(38)], }, // 34 - QuoteLBraceTerm: "'\{"; Production { - lhs: 504, + lhs: 516, production: &[ParseType::T(39)], }, // 35 - LBraceTerm: '{'; Production { - lhs: 356, + lhs: 360, production: &[ParseType::T(40)], }, // 36 - LBracketTerm: '['; Production { - lhs: 359, + lhs: 363, production: &[ParseType::T(41)], }, // 37 - LParenTerm: '('; Production { - lhs: 362, + lhs: 366, production: &[ParseType::T(42)], }, // 38 - RAngleTerm: '>'; Production { - lhs: 507, + lhs: 519, production: &[ParseType::T(43)], }, // 39 - RBraceTerm: '}'; Production { - lhs: 510, + lhs: 522, production: &[ParseType::T(44)], }, // 40 - RBracketTerm: ']'; Production { - lhs: 513, + lhs: 525, production: &[ParseType::T(45)], }, // 41 - RParenTerm: ')'; Production { - lhs: 516, + lhs: 528, production: &[ParseType::T(46)], }, // 42 - SemicolonTerm: ';'; Production { - lhs: 563, + lhs: 576, production: &[ParseType::T(47)], }, // 43 - StarTerm: '*'; Production { - lhs: 569, + lhs: 582, production: &[ParseType::T(48)], }, // 44 - AlwaysCombTerm: /(?-u:\b)always_comb(?-u:\b)/; @@ -17932,5047 +18096,5151 @@ pub const PRODUCTIONS: &[Production; 976] = &[ lhs: 85, production: &[ParseType::T(57)], }, - // 53 - DefaultTerm: /(?-u:\b)default(?-u:\b)/; + // 53 - ConstTerm: /(?-u:\b)const(?-u:\b)/; Production { lhs: 113, production: &[ParseType::T(58)], }, - // 54 - ElseTerm: /(?-u:\b)else(?-u:\b)/; + // 54 - DefaultTerm: /(?-u:\b)default(?-u:\b)/; Production { - lhs: 134, + lhs: 116, production: &[ParseType::T(59)], }, - // 55 - EmbedTerm: /(?-u:\b)embed(?-u:\b)/; + // 55 - ElseTerm: /(?-u:\b)else(?-u:\b)/; Production { - lhs: 143, + lhs: 137, production: &[ParseType::T(60)], }, - // 56 - EnumTerm: /(?-u:\b)enum(?-u:\b)/; + // 56 - EmbedTerm: /(?-u:\b)embed(?-u:\b)/; Production { - lhs: 156, + lhs: 146, production: &[ParseType::T(61)], }, - // 57 - ExportTerm: /(?-u:\b)export(?-u:\b)/; + // 57 - EnumTerm: /(?-u:\b)enum(?-u:\b)/; Production { - lhs: 168, + lhs: 159, production: &[ParseType::T(62)], }, - // 58 - F32Term: /(?-u:\b)f32(?-u:\b)/; + // 58 - ExportTerm: /(?-u:\b)export(?-u:\b)/; Production { - lhs: 203, + lhs: 171, production: &[ParseType::T(63)], }, - // 59 - F64Term: /(?-u:\b)f64(?-u:\b)/; + // 59 - F32Term: /(?-u:\b)f32(?-u:\b)/; Production { lhs: 206, production: &[ParseType::T(64)], }, - // 60 - FinalTerm: /(?-u:\b)final(?-u:\b)/; + // 60 - F64Term: /(?-u:\b)f64(?-u:\b)/; Production { - lhs: 214, + lhs: 209, production: &[ParseType::T(65)], }, - // 61 - ForTerm: /(?-u:\b)for(?-u:\b)/; + // 61 - FinalTerm: /(?-u:\b)final(?-u:\b)/; Production { - lhs: 224, + lhs: 217, production: &[ParseType::T(66)], }, - // 62 - FunctionTerm: /(?-u:\b)function(?-u:\b)/; + // 62 - ForTerm: /(?-u:\b)for(?-u:\b)/; Production { - lhs: 235, + lhs: 227, production: &[ParseType::T(67)], }, - // 63 - I32Term: /(?-u:\b)i32(?-u:\b)/; + // 63 - FunctionTerm: /(?-u:\b)function(?-u:\b)/; Production { - lhs: 245, + lhs: 238, production: &[ParseType::T(68)], }, - // 64 - I64Term: /(?-u:\b)i64(?-u:\b)/; + // 64 - I32Term: /(?-u:\b)i32(?-u:\b)/; Production { - lhs: 248, + lhs: 249, production: &[ParseType::T(69)], }, - // 65 - IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/; + // 65 - I64Term: /(?-u:\b)i64(?-u:\b)/; Production { - lhs: 265, + lhs: 252, production: &[ParseType::T(70)], }, - // 66 - IfTerm: /(?-u:\b)if(?-u:\b)/; + // 66 - IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/; Production { - lhs: 273, + lhs: 269, production: &[ParseType::T(71)], }, - // 67 - ImportTerm: /(?-u:\b)import(?-u:\b)/; + // 67 - IfTerm: /(?-u:\b)if(?-u:\b)/; Production { - lhs: 278, + lhs: 277, production: &[ParseType::T(72)], }, - // 68 - IncludeTerm: /(?-u:\b)include(?-u:\b)/; + // 68 - ImportTerm: /(?-u:\b)import(?-u:\b)/; Production { - lhs: 285, + lhs: 282, production: &[ParseType::T(73)], }, - // 69 - InitialTerm: /(?-u:\b)initial(?-u:\b)/; + // 69 - IncludeTerm: /(?-u:\b)include(?-u:\b)/; Production { - lhs: 290, + lhs: 289, production: &[ParseType::T(74)], }, - // 70 - InoutTerm: /(?-u:\b)inout(?-u:\b)/; + // 70 - InitialTerm: /(?-u:\b)initial(?-u:\b)/; Production { - lhs: 293, + lhs: 294, production: &[ParseType::T(75)], }, - // 71 - InputTerm: /(?-u:\b)input(?-u:\b)/; + // 71 - InoutTerm: /(?-u:\b)inout(?-u:\b)/; Production { - lhs: 296, + lhs: 297, production: &[ParseType::T(76)], }, - // 72 - InsideTerm: /(?-u:\b)inside(?-u:\b)/; + // 72 - InputTerm: /(?-u:\b)input(?-u:\b)/; Production { lhs: 300, production: &[ParseType::T(77)], }, - // 73 - InstTerm: /(?-u:\b)inst(?-u:\b)/; + // 73 - InsideTerm: /(?-u:\b)inside(?-u:\b)/; Production { - lhs: 326, + lhs: 304, production: &[ParseType::T(78)], }, - // 74 - InterfaceTerm: /(?-u:\b)interface(?-u:\b)/; + // 74 - InstTerm: /(?-u:\b)inst(?-u:\b)/; Production { - lhs: 350, + lhs: 330, production: &[ParseType::T(79)], }, - // 75 - InTerm: /(?-u:\b)in(?-u:\b)/; + // 75 - InterfaceTerm: /(?-u:\b)interface(?-u:\b)/; Production { - lhs: 281, + lhs: 354, production: &[ParseType::T(80)], }, - // 76 - LetTerm: /(?-u:\b)let(?-u:\b)/; + // 76 - InTerm: /(?-u:\b)in(?-u:\b)/; Production { - lhs: 369, + lhs: 285, production: &[ParseType::T(81)], }, - // 77 - LocalTerm: /(?-u:\b)local(?-u:\b)/; + // 77 - LetTerm: /(?-u:\b)let(?-u:\b)/; Production { - lhs: 374, + lhs: 373, production: &[ParseType::T(82)], }, - // 78 - LogicTerm: /(?-u:\b)logic(?-u:\b)/; + // 78 - LocalTerm: /(?-u:\b)local(?-u:\b)/; Production { - lhs: 377, + lhs: 378, production: &[ParseType::T(83)], }, - // 79 - LsbTerm: /(?-u:\b)lsb(?-u:\b)/; + // 79 - LogicTerm: /(?-u:\b)logic(?-u:\b)/; Production { - lhs: 380, + lhs: 381, production: &[ParseType::T(84)], }, - // 80 - ModportTerm: /(?-u:\b)modport(?-u:\b)/; + // 80 - LsbTerm: /(?-u:\b)lsb(?-u:\b)/; Production { - lhs: 397, + lhs: 384, production: &[ParseType::T(85)], }, - // 81 - ModuleTerm: /(?-u:\b)module(?-u:\b)/; + // 81 - ModportTerm: /(?-u:\b)modport(?-u:\b)/; Production { - lhs: 421, + lhs: 401, production: &[ParseType::T(86)], }, - // 82 - MsbTerm: /(?-u:\b)msb(?-u:\b)/; + // 82 - ModuleTerm: /(?-u:\b)module(?-u:\b)/; Production { - lhs: 424, + lhs: 426, production: &[ParseType::T(87)], }, - // 83 - OutputTerm: /(?-u:\b)output(?-u:\b)/; + // 83 - MsbTerm: /(?-u:\b)msb(?-u:\b)/; Production { - lhs: 461, + lhs: 429, production: &[ParseType::T(88)], }, - // 84 - OutsideTerm: /(?-u:\b)outside(?-u:\b)/; + // 84 - OutputTerm: /(?-u:\b)output(?-u:\b)/; Production { - lhs: 465, + lhs: 466, production: &[ParseType::T(89)], }, - // 85 - PackageTerm: /(?-u:\b)package(?-u:\b)/; + // 85 - OutsideTerm: /(?-u:\b)outside(?-u:\b)/; Production { - lhs: 477, + lhs: 470, production: &[ParseType::T(90)], }, - // 86 - ParamTerm: /(?-u:\b)param(?-u:\b)/; + // 86 - PackageTerm: /(?-u:\b)package(?-u:\b)/; Production { - lhs: 480, + lhs: 482, production: &[ParseType::T(91)], }, - // 87 - PubTerm: /(?-u:\b)pub(?-u:\b)/; + // 87 - ParamTerm: /(?-u:\b)param(?-u:\b)/; Production { - lhs: 501, + lhs: 485, production: &[ParseType::T(92)], }, - // 88 - RefTerm: /(?-u:\b)ref(?-u:\b)/; + // 88 - ProtoTerm: /(?-u:\b)proto(?-u:\b)/; Production { - lhs: 527, + lhs: 510, production: &[ParseType::T(93)], }, - // 89 - RepeatTerm: /(?-u:\b)repeat(?-u:\b)/; + // 89 - PubTerm: /(?-u:\b)pub(?-u:\b)/; Production { - lhs: 530, + lhs: 513, production: &[ParseType::T(94)], }, - // 90 - ResetTerm: /(?-u:\b)reset(?-u:\b)/; + // 90 - RefTerm: /(?-u:\b)ref(?-u:\b)/; Production { - lhs: 545, + lhs: 539, production: &[ParseType::T(95)], }, - // 91 - ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/; + // 91 - RepeatTerm: /(?-u:\b)repeat(?-u:\b)/; Production { - lhs: 534, + lhs: 542, production: &[ParseType::T(96)], }, - // 92 - ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/; + // 92 - ResetTerm: /(?-u:\b)reset(?-u:\b)/; Production { - lhs: 537, + lhs: 557, production: &[ParseType::T(97)], }, - // 93 - ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/; + // 93 - ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/; Production { - lhs: 540, + lhs: 546, production: &[ParseType::T(98)], }, - // 94 - ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/; + // 94 - ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/; Production { - lhs: 543, + lhs: 549, production: &[ParseType::T(99)], }, - // 95 - ReturnTerm: /(?-u:\b)return(?-u:\b)/; + // 95 - ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/; Production { - lhs: 549, + lhs: 552, production: &[ParseType::T(100)], }, - // 96 - BreakTerm: /(?-u:\b)break(?-u:\b)/; + // 96 - ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/; Production { - lhs: 65, + lhs: 555, production: &[ParseType::T(101)], }, - // 97 - SignedTerm: /(?-u:\b)signed(?-u:\b)/; + // 97 - ReturnTerm: /(?-u:\b)return(?-u:\b)/; Production { - lhs: 566, + lhs: 561, production: &[ParseType::T(102)], }, - // 98 - StepTerm: /(?-u:\b)step(?-u:\b)/; + // 98 - BreakTerm: /(?-u:\b)break(?-u:\b)/; Production { - lhs: 575, + lhs: 65, production: &[ParseType::T(103)], }, - // 99 - StringTerm: /(?-u:\b)string(?-u:\b)/; + // 99 - SignedTerm: /(?-u:\b)signed(?-u:\b)/; Production { - lhs: 581, + lhs: 579, production: &[ParseType::T(104)], }, - // 100 - StructTerm: /(?-u:\b)struct(?-u:\b)/; + // 100 - StepTerm: /(?-u:\b)step(?-u:\b)/; Production { - lhs: 584, + lhs: 588, production: &[ParseType::T(105)], }, - // 101 - SwitchTerm: /(?-u:\b)switch(?-u:\b)/; + // 101 - StringTerm: /(?-u:\b)string(?-u:\b)/; Production { - lhs: 608, + lhs: 594, production: &[ParseType::T(106)], }, - // 102 - TriTerm: /(?-u:\b)tri(?-u:\b)/; + // 102 - StructTerm: /(?-u:\b)struct(?-u:\b)/; Production { - lhs: 611, + lhs: 597, production: &[ParseType::T(107)], }, - // 103 - TypeTerm: /(?-u:\b)type(?-u:\b)/; + // 103 - SwitchTerm: /(?-u:\b)switch(?-u:\b)/; Production { - lhs: 617, + lhs: 621, production: &[ParseType::T(108)], }, - // 104 - U32Term: /(?-u:\b)u32(?-u:\b)/; + // 104 - TriTerm: /(?-u:\b)tri(?-u:\b)/; Production { - lhs: 620, + lhs: 624, production: &[ParseType::T(109)], }, - // 105 - U64Term: /(?-u:\b)u64(?-u:\b)/; + // 105 - TypeTerm: /(?-u:\b)type(?-u:\b)/; Production { - lhs: 623, + lhs: 630, production: &[ParseType::T(110)], }, - // 106 - UnionTerm: /(?-u:\b)union(?-u:\b)/; + // 106 - U32Term: /(?-u:\b)u32(?-u:\b)/; Production { - lhs: 629, + lhs: 633, production: &[ParseType::T(111)], }, - // 107 - UnsafeTerm: /(?-u:\b)unsafe(?-u:\b)/; + // 107 - U64Term: /(?-u:\b)u64(?-u:\b)/; Production { - lhs: 634, + lhs: 636, production: &[ParseType::T(112)], }, - // 108 - VarTerm: /(?-u:\b)var(?-u:\b)/; + // 108 - UnionTerm: /(?-u:\b)union(?-u:\b)/; Production { - lhs: 639, + lhs: 642, production: &[ParseType::T(113)], }, - // 109 - DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/; + // 109 - UnsafeTerm: /(?-u:\b)unsafe(?-u:\b)/; Production { - lhs: 122, + lhs: 647, production: &[ParseType::T(114)], }, - // 110 - IdentifierTerm: /(?:r#)?[a-zA-Z_][0-9a-zA-Z_$]*/; + // 110 - VarTerm: /(?-u:\b)var(?-u:\b)/; Production { - lhs: 253, + lhs: 652, production: &[ParseType::T(115)], }, - // 111 - AnyTerm: /[^{}]*/; + // 111 - DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/; Production { - lhs: 18, + lhs: 125, production: &[ParseType::T(116)], }, - // 112 - Comments: CommentsOpt /* Option */; + // 112 - IdentifierTerm: /(?:r#)?[a-zA-Z_][0-9a-zA-Z_$]*/; + Production { + lhs: 257, + production: &[ParseType::T(117)], + }, + // 113 - AnyTerm: /[^{}]*/; + Production { + lhs: 18, + production: &[ParseType::T(118)], + }, + // 114 - Comments: CommentsOpt /* Option */; Production { lhs: 104, production: &[ParseType::N(105)], }, - // 113 - CommentsOpt: CommentsTerm; + // 115 - CommentsOpt: CommentsTerm; Production { lhs: 105, production: &[ParseType::N(106)], }, - // 114 - CommentsOpt: ; + // 116 - CommentsOpt: ; Production { lhs: 105, production: &[], }, - // 115 - StartToken: Comments; + // 117 - StartToken: Comments; Production { - lhs: 572, + lhs: 585, production: &[ParseType::N(104)], }, - // 116 - StringLiteralToken: StringLiteralTerm : crate::veryl_token::Token Comments; + // 118 - StringLiteralToken: StringLiteralTerm : crate::veryl_token::Token Comments; Production { - lhs: 580, - production: &[ParseType::N(104), ParseType::N(579)], + lhs: 593, + production: &[ParseType::N(104), ParseType::N(592)], }, - // 117 - ExponentToken: ExponentTerm : crate::veryl_token::Token Comments; + // 119 - ExponentToken: ExponentTerm : crate::veryl_token::Token Comments; Production { - lhs: 163, - production: &[ParseType::N(104), ParseType::N(162)], + lhs: 166, + production: &[ParseType::N(104), ParseType::N(165)], }, - // 118 - FixedPointToken: FixedPointTerm : crate::veryl_token::Token Comments; + // 120 - FixedPointToken: FixedPointTerm : crate::veryl_token::Token Comments; Production { - lhs: 218, - production: &[ParseType::N(104), ParseType::N(217)], + lhs: 221, + production: &[ParseType::N(104), ParseType::N(220)], }, - // 119 - BasedToken: BasedTerm : crate::veryl_token::Token Comments; + // 121 - BasedToken: BasedTerm : crate::veryl_token::Token Comments; Production { lhs: 59, production: &[ParseType::N(104), ParseType::N(58)], }, - // 120 - BaseLessToken: BaseLessTerm : crate::veryl_token::Token Comments; + // 122 - BaseLessToken: BaseLessTerm : crate::veryl_token::Token Comments; Production { lhs: 56, production: &[ParseType::N(104), ParseType::N(55)], }, - // 121 - AllBitToken: AllBitTerm : crate::veryl_token::Token Comments; + // 123 - AllBitToken: AllBitTerm : crate::veryl_token::Token Comments; Production { lhs: 2, production: &[ParseType::N(104), ParseType::N(1)], }, - // 122 - AssignmentOperatorToken: AssignmentOperatorTerm : crate::veryl_token::Token Comments; + // 124 - AssignmentOperatorToken: AssignmentOperatorTerm : crate::veryl_token::Token Comments; Production { lhs: 44, production: &[ParseType::N(104), ParseType::N(43)], }, - // 123 - Operator01Token: Operator01Term : crate::veryl_token::Token Comments; + // 125 - Operator01Token: Operator01Term : crate::veryl_token::Token Comments; Production { - lhs: 429, - production: &[ParseType::N(104), ParseType::N(428)], + lhs: 434, + production: &[ParseType::N(104), ParseType::N(433)], }, - // 124 - Operator02Token: Operator02Term : crate::veryl_token::Token Comments; + // 126 - Operator02Token: Operator02Term : crate::veryl_token::Token Comments; Production { - lhs: 432, - production: &[ParseType::N(104), ParseType::N(431)], + lhs: 437, + production: &[ParseType::N(104), ParseType::N(436)], }, - // 125 - Operator03Token: Operator03Term : crate::veryl_token::Token Comments; + // 127 - Operator03Token: Operator03Term : crate::veryl_token::Token Comments; Production { - lhs: 435, - production: &[ParseType::N(104), ParseType::N(434)], + lhs: 440, + production: &[ParseType::N(104), ParseType::N(439)], }, - // 126 - Operator04Token: Operator04Term : crate::veryl_token::Token Comments; + // 128 - Operator04Token: Operator04Term : crate::veryl_token::Token Comments; Production { - lhs: 438, - production: &[ParseType::N(104), ParseType::N(437)], + lhs: 443, + production: &[ParseType::N(104), ParseType::N(442)], }, - // 127 - Operator05Token: Operator05Term : crate::veryl_token::Token Comments; + // 129 - Operator05Token: Operator05Term : crate::veryl_token::Token Comments; Production { - lhs: 441, - production: &[ParseType::N(104), ParseType::N(440)], + lhs: 446, + production: &[ParseType::N(104), ParseType::N(445)], }, - // 128 - Operator06Token: Operator06Term : crate::veryl_token::Token Comments; + // 130 - Operator06Token: Operator06Term : crate::veryl_token::Token Comments; Production { - lhs: 444, - production: &[ParseType::N(104), ParseType::N(443)], + lhs: 449, + production: &[ParseType::N(104), ParseType::N(448)], }, - // 129 - Operator07Token: Operator07Term : crate::veryl_token::Token Comments; + // 131 - Operator07Token: Operator07Term : crate::veryl_token::Token Comments; Production { - lhs: 447, - production: &[ParseType::N(104), ParseType::N(446)], + lhs: 452, + production: &[ParseType::N(104), ParseType::N(451)], }, - // 130 - Operator08Token: Operator08Term : crate::veryl_token::Token Comments; + // 132 - Operator08Token: Operator08Term : crate::veryl_token::Token Comments; Production { - lhs: 450, - production: &[ParseType::N(104), ParseType::N(449)], + lhs: 455, + production: &[ParseType::N(104), ParseType::N(454)], }, - // 131 - Operator09Token: Operator09Term : crate::veryl_token::Token Comments; + // 133 - Operator09Token: Operator09Term : crate::veryl_token::Token Comments; Production { - lhs: 453, - production: &[ParseType::N(104), ParseType::N(452)], + lhs: 458, + production: &[ParseType::N(104), ParseType::N(457)], }, - // 132 - Operator10Token: Operator10Term : crate::veryl_token::Token Comments; + // 134 - Operator10Token: Operator10Term : crate::veryl_token::Token Comments; Production { - lhs: 456, - production: &[ParseType::N(104), ParseType::N(455)], + lhs: 461, + production: &[ParseType::N(104), ParseType::N(460)], }, - // 133 - Operator11Token: Operator11Term : crate::veryl_token::Token Comments; + // 135 - Operator11Token: Operator11Term : crate::veryl_token::Token Comments; Production { - lhs: 459, - production: &[ParseType::N(104), ParseType::N(458)], + lhs: 464, + production: &[ParseType::N(104), ParseType::N(463)], }, - // 134 - UnaryOperatorToken: UnaryOperatorTerm : crate::veryl_token::Token Comments; + // 136 - UnaryOperatorToken: UnaryOperatorTerm : crate::veryl_token::Token Comments; Production { - lhs: 627, - production: &[ParseType::N(104), ParseType::N(626)], + lhs: 640, + production: &[ParseType::N(104), ParseType::N(639)], }, - // 135 - BackQuoteToken: BackQuoteTerm : crate::veryl_token::Token Comments; + // 137 - BackQuoteToken: BackQuoteTerm : crate::veryl_token::Token Comments; Production { lhs: 53, production: &[ParseType::N(104), ParseType::N(52)], }, - // 136 - ColonToken: ColonTerm : crate::veryl_token::Token Comments; + // 138 - ColonToken: ColonTerm : crate::veryl_token::Token Comments; Production { lhs: 100, production: &[ParseType::N(104), ParseType::N(99)], }, - // 137 - ColonColonLAngleToken: ColonColonLAngleTerm : crate::veryl_token::Token Comments; + // 139 - ColonColonLAngleToken: ColonColonLAngleTerm : crate::veryl_token::Token Comments; Production { lhs: 96, production: &[ParseType::N(104), ParseType::N(95)], }, - // 138 - ColonColonToken: ColonColonTerm : crate::veryl_token::Token Comments; + // 140 - ColonColonToken: ColonColonTerm : crate::veryl_token::Token Comments; Production { lhs: 98, production: &[ParseType::N(104), ParseType::N(97)], }, - // 139 - CommaToken: CommaTerm : crate::veryl_token::Token Comments; + // 141 - CommaToken: CommaTerm : crate::veryl_token::Token Comments; Production { lhs: 103, production: &[ParseType::N(104), ParseType::N(102)], }, - // 140 - DotDotToken: DotDotTerm : crate::veryl_token::Token Comments; + // 142 - DotDotToken: DotDotTerm : crate::veryl_token::Token Comments; Production { - lhs: 130, - production: &[ParseType::N(104), ParseType::N(129)], + lhs: 133, + production: &[ParseType::N(104), ParseType::N(132)], }, - // 141 - DotDotEquToken: DotDotEquTerm : crate::veryl_token::Token Comments; + // 143 - DotDotEquToken: DotDotEquTerm : crate::veryl_token::Token Comments; Production { - lhs: 128, - production: &[ParseType::N(104), ParseType::N(127)], + lhs: 131, + production: &[ParseType::N(104), ParseType::N(130)], }, - // 142 - DotToken: DotTerm : crate::veryl_token::Token Comments; + // 144 - DotToken: DotTerm : crate::veryl_token::Token Comments; Production { - lhs: 132, - production: &[ParseType::N(104), ParseType::N(131)], + lhs: 135, + production: &[ParseType::N(104), ParseType::N(134)], }, - // 143 - EquToken: EquTerm : crate::veryl_token::Token Comments; + // 145 - EquToken: EquTerm : crate::veryl_token::Token Comments; Production { - lhs: 160, - production: &[ParseType::N(104), ParseType::N(159)], + lhs: 163, + production: &[ParseType::N(104), ParseType::N(162)], }, - // 144 - HashToken: HashTerm : crate::veryl_token::Token Comments; + // 146 - HashToken: HashTerm : crate::veryl_token::Token Comments; Production { - lhs: 239, - production: &[ParseType::N(104), ParseType::N(238)], + lhs: 243, + production: &[ParseType::N(104), ParseType::N(242)], }, - // 145 - QuoteLBraceToken: QuoteLBraceTerm : crate::veryl_token::Token Comments; + // 147 - QuoteLBraceToken: QuoteLBraceTerm : crate::veryl_token::Token Comments; Production { - lhs: 505, - production: &[ParseType::N(104), ParseType::N(504)], + lhs: 517, + production: &[ParseType::N(104), ParseType::N(516)], }, - // 146 - LAngleToken: LAngleTerm : crate::veryl_token::Token Comments; + // 148 - LAngleToken: LAngleTerm : crate::veryl_token::Token Comments; Production { - lhs: 354, - production: &[ParseType::N(104), ParseType::N(353)], + lhs: 358, + production: &[ParseType::N(104), ParseType::N(357)], }, - // 147 - LBraceToken: LBraceTerm : crate::veryl_token::Token Comments; + // 149 - LBraceToken: LBraceTerm : crate::veryl_token::Token Comments; Production { - lhs: 357, - production: &[ParseType::N(104), ParseType::N(356)], + lhs: 361, + production: &[ParseType::N(104), ParseType::N(360)], }, - // 148 - LBracketToken: LBracketTerm : crate::veryl_token::Token Comments; + // 150 - LBracketToken: LBracketTerm : crate::veryl_token::Token Comments; Production { - lhs: 360, - production: &[ParseType::N(104), ParseType::N(359)], + lhs: 364, + production: &[ParseType::N(104), ParseType::N(363)], }, - // 149 - LParenToken: LParenTerm : crate::veryl_token::Token Comments; + // 151 - LParenToken: LParenTerm : crate::veryl_token::Token Comments; Production { - lhs: 363, - production: &[ParseType::N(104), ParseType::N(362)], + lhs: 367, + production: &[ParseType::N(104), ParseType::N(366)], }, - // 150 - MinusColonToken: MinusColonTerm : crate::veryl_token::Token Comments; + // 152 - MinusColonToken: MinusColonTerm : crate::veryl_token::Token Comments; Production { - lhs: 384, - production: &[ParseType::N(104), ParseType::N(383)], + lhs: 388, + production: &[ParseType::N(104), ParseType::N(387)], }, - // 151 - MinusGTToken: MinusGTTerm : crate::veryl_token::Token Comments; + // 153 - MinusGTToken: MinusGTTerm : crate::veryl_token::Token Comments; Production { - lhs: 387, - production: &[ParseType::N(104), ParseType::N(386)], + lhs: 391, + production: &[ParseType::N(104), ParseType::N(390)], }, - // 152 - PlusColonToken: PlusColonTerm : crate::veryl_token::Token Comments; + // 154 - PlusColonToken: PlusColonTerm : crate::veryl_token::Token Comments; Production { - lhs: 484, - production: &[ParseType::N(104), ParseType::N(483)], + lhs: 489, + production: &[ParseType::N(104), ParseType::N(488)], }, - // 153 - RAngleToken: RAngleTerm : crate::veryl_token::Token Comments; + // 155 - RAngleToken: RAngleTerm : crate::veryl_token::Token Comments; Production { - lhs: 508, - production: &[ParseType::N(104), ParseType::N(507)], + lhs: 520, + production: &[ParseType::N(104), ParseType::N(519)], }, - // 154 - RBraceToken: RBraceTerm : crate::veryl_token::Token Comments; + // 156 - RBraceToken: RBraceTerm : crate::veryl_token::Token Comments; Production { - lhs: 511, - production: &[ParseType::N(104), ParseType::N(510)], + lhs: 523, + production: &[ParseType::N(104), ParseType::N(522)], }, - // 155 - RBracketToken: RBracketTerm : crate::veryl_token::Token Comments; + // 157 - RBracketToken: RBracketTerm : crate::veryl_token::Token Comments; Production { - lhs: 514, - production: &[ParseType::N(104), ParseType::N(513)], + lhs: 526, + production: &[ParseType::N(104), ParseType::N(525)], }, - // 156 - RParenToken: RParenTerm : crate::veryl_token::Token Comments; + // 158 - RParenToken: RParenTerm : crate::veryl_token::Token Comments; Production { - lhs: 517, - production: &[ParseType::N(104), ParseType::N(516)], + lhs: 529, + production: &[ParseType::N(104), ParseType::N(528)], }, - // 157 - SemicolonToken: SemicolonTerm : crate::veryl_token::Token Comments; + // 159 - SemicolonToken: SemicolonTerm : crate::veryl_token::Token Comments; Production { - lhs: 564, - production: &[ParseType::N(104), ParseType::N(563)], + lhs: 577, + production: &[ParseType::N(104), ParseType::N(576)], }, - // 158 - StarToken: StarTerm : crate::veryl_token::Token Comments; + // 160 - StarToken: StarTerm : crate::veryl_token::Token Comments; Production { - lhs: 570, - production: &[ParseType::N(104), ParseType::N(569)], + lhs: 583, + production: &[ParseType::N(104), ParseType::N(582)], }, - // 159 - AlwaysCombToken: AlwaysCombTerm : crate::veryl_token::Token Comments; + // 161 - AlwaysCombToken: AlwaysCombTerm : crate::veryl_token::Token Comments; Production { lhs: 9, production: &[ParseType::N(104), ParseType::N(8)], }, - // 160 - AlwaysFfToken: AlwaysFfTerm : crate::veryl_token::Token Comments; + // 162 - AlwaysFfToken: AlwaysFfTerm : crate::veryl_token::Token Comments; Production { lhs: 17, production: &[ParseType::N(104), ParseType::N(16)], }, - // 161 - AsToken: AsTerm : crate::veryl_token::Token Comments; + // 163 - AsToken: AsTerm : crate::veryl_token::Token Comments; Production { lhs: 35, production: &[ParseType::N(104), ParseType::N(34)], }, - // 162 - AssignToken: AssignTerm : crate::veryl_token::Token Comments; + // 164 - AssignToken: AssignTerm : crate::veryl_token::Token Comments; Production { lhs: 39, production: &[ParseType::N(104), ParseType::N(38)], }, - // 163 - BitToken: BitTerm : crate::veryl_token::Token Comments; + // 165 - BitToken: BitTerm : crate::veryl_token::Token Comments; Production { lhs: 62, production: &[ParseType::N(104), ParseType::N(61)], }, - // 164 - CaseToken: CaseTerm : crate::veryl_token::Token Comments; + // 166 - CaseToken: CaseTerm : crate::veryl_token::Token Comments; Production { lhs: 80, production: &[ParseType::N(104), ParseType::N(79)], }, - // 165 - ClockToken: ClockTerm : crate::veryl_token::Token Comments; + // 167 - ClockToken: ClockTerm : crate::veryl_token::Token Comments; Production { lhs: 91, production: &[ParseType::N(104), ParseType::N(90)], }, - // 166 - ClockPosedgeToken: ClockPosedgeTerm : crate::veryl_token::Token Comments; + // 168 - ClockPosedgeToken: ClockPosedgeTerm : crate::veryl_token::Token Comments; Production { lhs: 89, production: &[ParseType::N(104), ParseType::N(88)], }, - // 167 - ClockNegedgeToken: ClockNegedgeTerm : crate::veryl_token::Token Comments; + // 169 - ClockNegedgeToken: ClockNegedgeTerm : crate::veryl_token::Token Comments; Production { lhs: 86, production: &[ParseType::N(104), ParseType::N(85)], }, - // 168 - DefaultToken: DefaultTerm : crate::veryl_token::Token Comments; + // 170 - ConstToken: ConstTerm : crate::veryl_token::Token Comments; Production { lhs: 114, production: &[ParseType::N(104), ParseType::N(113)], }, - // 169 - ElseToken: ElseTerm : crate::veryl_token::Token Comments; + // 171 - DefaultToken: DefaultTerm : crate::veryl_token::Token Comments; Production { - lhs: 135, - production: &[ParseType::N(104), ParseType::N(134)], + lhs: 117, + production: &[ParseType::N(104), ParseType::N(116)], }, - // 170 - EmbedToken: EmbedTerm : crate::veryl_token::Token Comments; + // 172 - ElseToken: ElseTerm : crate::veryl_token::Token Comments; Production { - lhs: 144, - production: &[ParseType::N(104), ParseType::N(143)], + lhs: 138, + production: &[ParseType::N(104), ParseType::N(137)], }, - // 171 - EnumToken: EnumTerm : crate::veryl_token::Token Comments; + // 173 - EmbedToken: EmbedTerm : crate::veryl_token::Token Comments; Production { - lhs: 157, - production: &[ParseType::N(104), ParseType::N(156)], + lhs: 147, + production: &[ParseType::N(104), ParseType::N(146)], }, - // 172 - ExportToken: ExportTerm : crate::veryl_token::Token Comments; + // 174 - EnumToken: EnumTerm : crate::veryl_token::Token Comments; Production { - lhs: 169, - production: &[ParseType::N(104), ParseType::N(168)], + lhs: 160, + production: &[ParseType::N(104), ParseType::N(159)], }, - // 173 - F32Token: F32Term : crate::veryl_token::Token Comments; + // 175 - ExportToken: ExportTerm : crate::veryl_token::Token Comments; Production { - lhs: 204, - production: &[ParseType::N(104), ParseType::N(203)], + lhs: 172, + production: &[ParseType::N(104), ParseType::N(171)], }, - // 174 - F64Token: F64Term : crate::veryl_token::Token Comments; + // 176 - F32Token: F32Term : crate::veryl_token::Token Comments; Production { lhs: 207, production: &[ParseType::N(104), ParseType::N(206)], }, - // 175 - FinalToken: FinalTerm : crate::veryl_token::Token Comments; + // 177 - F64Token: F64Term : crate::veryl_token::Token Comments; Production { - lhs: 215, - production: &[ParseType::N(104), ParseType::N(214)], + lhs: 210, + production: &[ParseType::N(104), ParseType::N(209)], }, - // 176 - ForToken: ForTerm : crate::veryl_token::Token Comments; + // 178 - FinalToken: FinalTerm : crate::veryl_token::Token Comments; Production { - lhs: 225, - production: &[ParseType::N(104), ParseType::N(224)], + lhs: 218, + production: &[ParseType::N(104), ParseType::N(217)], }, - // 177 - FunctionToken: FunctionTerm : crate::veryl_token::Token Comments; + // 179 - ForToken: ForTerm : crate::veryl_token::Token Comments; Production { - lhs: 236, - production: &[ParseType::N(104), ParseType::N(235)], + lhs: 228, + production: &[ParseType::N(104), ParseType::N(227)], }, - // 178 - I32Token: I32Term : crate::veryl_token::Token Comments; + // 180 - FunctionToken: FunctionTerm : crate::veryl_token::Token Comments; Production { - lhs: 246, - production: &[ParseType::N(104), ParseType::N(245)], + lhs: 239, + production: &[ParseType::N(104), ParseType::N(238)], }, - // 179 - I64Token: I64Term : crate::veryl_token::Token Comments; + // 181 - I32Token: I32Term : crate::veryl_token::Token Comments; Production { - lhs: 249, - production: &[ParseType::N(104), ParseType::N(248)], + lhs: 250, + production: &[ParseType::N(104), ParseType::N(249)], }, - // 180 - IfResetToken: IfResetTerm : crate::veryl_token::Token Comments; + // 182 - I64Token: I64Term : crate::veryl_token::Token Comments; Production { - lhs: 266, - production: &[ParseType::N(104), ParseType::N(265)], + lhs: 253, + production: &[ParseType::N(104), ParseType::N(252)], }, - // 181 - IfToken: IfTerm : crate::veryl_token::Token Comments; + // 183 - IfResetToken: IfResetTerm : crate::veryl_token::Token Comments; Production { - lhs: 274, - production: &[ParseType::N(104), ParseType::N(273)], + lhs: 270, + production: &[ParseType::N(104), ParseType::N(269)], }, - // 182 - ImportToken: ImportTerm : crate::veryl_token::Token Comments; + // 184 - IfToken: IfTerm : crate::veryl_token::Token Comments; Production { - lhs: 279, - production: &[ParseType::N(104), ParseType::N(278)], + lhs: 278, + production: &[ParseType::N(104), ParseType::N(277)], }, - // 183 - IncludeToken: IncludeTerm : crate::veryl_token::Token Comments; + // 185 - ImportToken: ImportTerm : crate::veryl_token::Token Comments; Production { - lhs: 286, - production: &[ParseType::N(104), ParseType::N(285)], + lhs: 283, + production: &[ParseType::N(104), ParseType::N(282)], }, - // 184 - InitialToken: InitialTerm : crate::veryl_token::Token Comments; + // 186 - IncludeToken: IncludeTerm : crate::veryl_token::Token Comments; Production { - lhs: 291, - production: &[ParseType::N(104), ParseType::N(290)], + lhs: 290, + production: &[ParseType::N(104), ParseType::N(289)], }, - // 185 - InoutToken: InoutTerm : crate::veryl_token::Token Comments; + // 187 - InitialToken: InitialTerm : crate::veryl_token::Token Comments; Production { - lhs: 294, - production: &[ParseType::N(104), ParseType::N(293)], + lhs: 295, + production: &[ParseType::N(104), ParseType::N(294)], }, - // 186 - InputToken: InputTerm : crate::veryl_token::Token Comments; + // 188 - InoutToken: InoutTerm : crate::veryl_token::Token Comments; Production { - lhs: 297, - production: &[ParseType::N(104), ParseType::N(296)], + lhs: 298, + production: &[ParseType::N(104), ParseType::N(297)], }, - // 187 - InsideToken: InsideTerm : crate::veryl_token::Token Comments; + // 189 - InputToken: InputTerm : crate::veryl_token::Token Comments; Production { lhs: 301, production: &[ParseType::N(104), ParseType::N(300)], }, - // 188 - InstToken: InstTerm : crate::veryl_token::Token Comments; - Production { - lhs: 327, - production: &[ParseType::N(104), ParseType::N(326)], - }, - // 189 - InterfaceToken: InterfaceTerm : crate::veryl_token::Token Comments; + // 190 - InsideToken: InsideTerm : crate::veryl_token::Token Comments; Production { - lhs: 351, - production: &[ParseType::N(104), ParseType::N(350)], + lhs: 305, + production: &[ParseType::N(104), ParseType::N(304)], }, - // 190 - InToken: InTerm : crate::veryl_token::Token Comments; + // 191 - InstToken: InstTerm : crate::veryl_token::Token Comments; Production { - lhs: 282, - production: &[ParseType::N(104), ParseType::N(281)], + lhs: 331, + production: &[ParseType::N(104), ParseType::N(330)], }, - // 191 - LetToken: LetTerm : crate::veryl_token::Token Comments; + // 192 - InterfaceToken: InterfaceTerm : crate::veryl_token::Token Comments; Production { - lhs: 370, - production: &[ParseType::N(104), ParseType::N(369)], + lhs: 355, + production: &[ParseType::N(104), ParseType::N(354)], }, - // 192 - LocalToken: LocalTerm : crate::veryl_token::Token Comments; + // 193 - InToken: InTerm : crate::veryl_token::Token Comments; Production { - lhs: 375, - production: &[ParseType::N(104), ParseType::N(374)], + lhs: 286, + production: &[ParseType::N(104), ParseType::N(285)], }, - // 193 - LogicToken: LogicTerm : crate::veryl_token::Token Comments; + // 194 - LetToken: LetTerm : crate::veryl_token::Token Comments; Production { - lhs: 378, - production: &[ParseType::N(104), ParseType::N(377)], + lhs: 374, + production: &[ParseType::N(104), ParseType::N(373)], }, - // 194 - LsbToken: LsbTerm : crate::veryl_token::Token Comments; + // 195 - LocalToken: LocalTerm : crate::veryl_token::Token Comments; Production { - lhs: 381, - production: &[ParseType::N(104), ParseType::N(380)], + lhs: 379, + production: &[ParseType::N(104), ParseType::N(378)], }, - // 195 - ModportToken: ModportTerm : crate::veryl_token::Token Comments; + // 196 - LogicToken: LogicTerm : crate::veryl_token::Token Comments; Production { - lhs: 398, - production: &[ParseType::N(104), ParseType::N(397)], + lhs: 382, + production: &[ParseType::N(104), ParseType::N(381)], }, - // 196 - ModuleToken: ModuleTerm : crate::veryl_token::Token Comments; + // 197 - LsbToken: LsbTerm : crate::veryl_token::Token Comments; Production { - lhs: 422, - production: &[ParseType::N(104), ParseType::N(421)], + lhs: 385, + production: &[ParseType::N(104), ParseType::N(384)], }, - // 197 - MsbToken: MsbTerm : crate::veryl_token::Token Comments; + // 198 - ModportToken: ModportTerm : crate::veryl_token::Token Comments; Production { - lhs: 425, - production: &[ParseType::N(104), ParseType::N(424)], + lhs: 402, + production: &[ParseType::N(104), ParseType::N(401)], }, - // 198 - OutputToken: OutputTerm : crate::veryl_token::Token Comments; + // 199 - ModuleToken: ModuleTerm : crate::veryl_token::Token Comments; Production { - lhs: 462, - production: &[ParseType::N(104), ParseType::N(461)], + lhs: 427, + production: &[ParseType::N(104), ParseType::N(426)], }, - // 199 - OutsideToken: OutsideTerm : crate::veryl_token::Token Comments; + // 200 - MsbToken: MsbTerm : crate::veryl_token::Token Comments; Production { - lhs: 466, - production: &[ParseType::N(104), ParseType::N(465)], + lhs: 430, + production: &[ParseType::N(104), ParseType::N(429)], }, - // 200 - PackageToken: PackageTerm : crate::veryl_token::Token Comments; + // 201 - OutputToken: OutputTerm : crate::veryl_token::Token Comments; Production { - lhs: 478, - production: &[ParseType::N(104), ParseType::N(477)], + lhs: 467, + production: &[ParseType::N(104), ParseType::N(466)], }, - // 201 - ParamToken: ParamTerm : crate::veryl_token::Token Comments; + // 202 - OutsideToken: OutsideTerm : crate::veryl_token::Token Comments; Production { - lhs: 481, - production: &[ParseType::N(104), ParseType::N(480)], + lhs: 471, + production: &[ParseType::N(104), ParseType::N(470)], }, - // 202 - PubToken: PubTerm : crate::veryl_token::Token Comments; + // 203 - PackageToken: PackageTerm : crate::veryl_token::Token Comments; Production { - lhs: 502, - production: &[ParseType::N(104), ParseType::N(501)], + lhs: 483, + production: &[ParseType::N(104), ParseType::N(482)], }, - // 203 - RefToken: RefTerm : crate::veryl_token::Token Comments; + // 204 - ParamToken: ParamTerm : crate::veryl_token::Token Comments; Production { - lhs: 528, - production: &[ParseType::N(104), ParseType::N(527)], + lhs: 486, + production: &[ParseType::N(104), ParseType::N(485)], }, - // 204 - RepeatToken: RepeatTerm : crate::veryl_token::Token Comments; + // 205 - ProtoToken: ProtoTerm : crate::veryl_token::Token Comments; Production { - lhs: 531, - production: &[ParseType::N(104), ParseType::N(530)], + lhs: 511, + production: &[ParseType::N(104), ParseType::N(510)], }, - // 205 - ResetToken: ResetTerm : crate::veryl_token::Token Comments; + // 206 - PubToken: PubTerm : crate::veryl_token::Token Comments; Production { - lhs: 546, - production: &[ParseType::N(104), ParseType::N(545)], + lhs: 514, + production: &[ParseType::N(104), ParseType::N(513)], }, - // 206 - ResetAsyncHighToken: ResetAsyncHighTerm : crate::veryl_token::Token Comments; + // 207 - RefToken: RefTerm : crate::veryl_token::Token Comments; Production { - lhs: 535, - production: &[ParseType::N(104), ParseType::N(534)], + lhs: 540, + production: &[ParseType::N(104), ParseType::N(539)], }, - // 207 - ResetAsyncLowToken: ResetAsyncLowTerm : crate::veryl_token::Token Comments; + // 208 - RepeatToken: RepeatTerm : crate::veryl_token::Token Comments; Production { - lhs: 538, - production: &[ParseType::N(104), ParseType::N(537)], + lhs: 543, + production: &[ParseType::N(104), ParseType::N(542)], }, - // 208 - ResetSyncHighToken: ResetSyncHighTerm : crate::veryl_token::Token Comments; + // 209 - ResetToken: ResetTerm : crate::veryl_token::Token Comments; Production { - lhs: 541, - production: &[ParseType::N(104), ParseType::N(540)], + lhs: 558, + production: &[ParseType::N(104), ParseType::N(557)], }, - // 209 - ResetSyncLowToken: ResetSyncLowTerm : crate::veryl_token::Token Comments; + // 210 - ResetAsyncHighToken: ResetAsyncHighTerm : crate::veryl_token::Token Comments; Production { - lhs: 544, - production: &[ParseType::N(104), ParseType::N(543)], + lhs: 547, + production: &[ParseType::N(104), ParseType::N(546)], }, - // 210 - ReturnToken: ReturnTerm : crate::veryl_token::Token Comments; + // 211 - ResetAsyncLowToken: ResetAsyncLowTerm : crate::veryl_token::Token Comments; Production { lhs: 550, production: &[ParseType::N(104), ParseType::N(549)], }, - // 211 - BreakToken: BreakTerm : crate::veryl_token::Token Comments; + // 212 - ResetSyncHighToken: ResetSyncHighTerm : crate::veryl_token::Token Comments; + Production { + lhs: 553, + production: &[ParseType::N(104), ParseType::N(552)], + }, + // 213 - ResetSyncLowToken: ResetSyncLowTerm : crate::veryl_token::Token Comments; + Production { + lhs: 556, + production: &[ParseType::N(104), ParseType::N(555)], + }, + // 214 - ReturnToken: ReturnTerm : crate::veryl_token::Token Comments; + Production { + lhs: 562, + production: &[ParseType::N(104), ParseType::N(561)], + }, + // 215 - BreakToken: BreakTerm : crate::veryl_token::Token Comments; Production { lhs: 66, production: &[ParseType::N(104), ParseType::N(65)], }, - // 212 - SignedToken: SignedTerm : crate::veryl_token::Token Comments; + // 216 - SignedToken: SignedTerm : crate::veryl_token::Token Comments; Production { - lhs: 567, - production: &[ParseType::N(104), ParseType::N(566)], + lhs: 580, + production: &[ParseType::N(104), ParseType::N(579)], }, - // 213 - StepToken: StepTerm : crate::veryl_token::Token Comments; + // 217 - StepToken: StepTerm : crate::veryl_token::Token Comments; Production { - lhs: 576, - production: &[ParseType::N(104), ParseType::N(575)], + lhs: 589, + production: &[ParseType::N(104), ParseType::N(588)], }, - // 214 - StringToken: StringTerm : crate::veryl_token::Token Comments; + // 218 - StringToken: StringTerm : crate::veryl_token::Token Comments; Production { - lhs: 582, - production: &[ParseType::N(104), ParseType::N(581)], + lhs: 595, + production: &[ParseType::N(104), ParseType::N(594)], }, - // 215 - StructToken: StructTerm : crate::veryl_token::Token Comments; + // 219 - StructToken: StructTerm : crate::veryl_token::Token Comments; Production { - lhs: 585, - production: &[ParseType::N(104), ParseType::N(584)], + lhs: 598, + production: &[ParseType::N(104), ParseType::N(597)], }, - // 216 - SwitchToken: SwitchTerm : crate::veryl_token::Token Comments; + // 220 - SwitchToken: SwitchTerm : crate::veryl_token::Token Comments; Production { - lhs: 609, - production: &[ParseType::N(104), ParseType::N(608)], + lhs: 622, + production: &[ParseType::N(104), ParseType::N(621)], }, - // 217 - TriToken: TriTerm : crate::veryl_token::Token Comments; + // 221 - TriToken: TriTerm : crate::veryl_token::Token Comments; Production { - lhs: 612, - production: &[ParseType::N(104), ParseType::N(611)], + lhs: 625, + production: &[ParseType::N(104), ParseType::N(624)], }, - // 218 - TypeToken: TypeTerm : crate::veryl_token::Token Comments; + // 222 - TypeToken: TypeTerm : crate::veryl_token::Token Comments; Production { - lhs: 618, - production: &[ParseType::N(104), ParseType::N(617)], + lhs: 631, + production: &[ParseType::N(104), ParseType::N(630)], }, - // 219 - U32Token: U32Term : crate::veryl_token::Token Comments; + // 223 - U32Token: U32Term : crate::veryl_token::Token Comments; Production { - lhs: 621, - production: &[ParseType::N(104), ParseType::N(620)], + lhs: 634, + production: &[ParseType::N(104), ParseType::N(633)], }, - // 220 - U64Token: U64Term : crate::veryl_token::Token Comments; + // 224 - U64Token: U64Term : crate::veryl_token::Token Comments; Production { - lhs: 624, - production: &[ParseType::N(104), ParseType::N(623)], + lhs: 637, + production: &[ParseType::N(104), ParseType::N(636)], }, - // 221 - UnionToken: UnionTerm : crate::veryl_token::Token Comments; + // 225 - UnionToken: UnionTerm : crate::veryl_token::Token Comments; Production { - lhs: 630, - production: &[ParseType::N(104), ParseType::N(629)], + lhs: 643, + production: &[ParseType::N(104), ParseType::N(642)], }, - // 222 - UnsafeToken: UnsafeTerm : crate::veryl_token::Token Comments; + // 226 - UnsafeToken: UnsafeTerm : crate::veryl_token::Token Comments; Production { - lhs: 635, - production: &[ParseType::N(104), ParseType::N(634)], + lhs: 648, + production: &[ParseType::N(104), ParseType::N(647)], }, - // 223 - VarToken: VarTerm : crate::veryl_token::Token Comments; + // 227 - VarToken: VarTerm : crate::veryl_token::Token Comments; Production { - lhs: 640, - production: &[ParseType::N(104), ParseType::N(639)], + lhs: 653, + production: &[ParseType::N(104), ParseType::N(652)], }, - // 224 - DollarIdentifierToken: DollarIdentifierTerm : crate::veryl_token::Token Comments; + // 228 - DollarIdentifierToken: DollarIdentifierTerm : crate::veryl_token::Token Comments; Production { - lhs: 123, - production: &[ParseType::N(104), ParseType::N(122)], + lhs: 126, + production: &[ParseType::N(104), ParseType::N(125)], }, - // 225 - IdentifierToken: IdentifierTerm : crate::veryl_token::Token Comments; + // 229 - IdentifierToken: IdentifierTerm : crate::veryl_token::Token Comments; Production { - lhs: 254, - production: &[ParseType::N(104), ParseType::N(253)], + lhs: 258, + production: &[ParseType::N(104), ParseType::N(257)], }, - // 226 - Start: StartToken : crate::veryl_token::VerylToken ; + // 230 - Start: StartToken : crate::veryl_token::VerylToken ; Production { - lhs: 571, - production: &[ParseType::N(572)], + lhs: 584, + production: &[ParseType::N(585)], }, - // 227 - StringLiteral: StringLiteralToken : crate::veryl_token::VerylToken ; + // 231 - StringLiteral: StringLiteralToken : crate::veryl_token::VerylToken ; Production { - lhs: 578, - production: &[ParseType::N(580)], + lhs: 591, + production: &[ParseType::N(593)], }, - // 228 - Exponent: ExponentToken : crate::veryl_token::VerylToken ; + // 232 - Exponent: ExponentToken : crate::veryl_token::VerylToken ; Production { - lhs: 161, - production: &[ParseType::N(163)], + lhs: 164, + production: &[ParseType::N(166)], }, - // 229 - FixedPoint: FixedPointToken : crate::veryl_token::VerylToken ; + // 233 - FixedPoint: FixedPointToken : crate::veryl_token::VerylToken ; Production { - lhs: 216, - production: &[ParseType::N(218)], + lhs: 219, + production: &[ParseType::N(221)], }, - // 230 - Based: BasedToken : crate::veryl_token::VerylToken ; + // 234 - Based: BasedToken : crate::veryl_token::VerylToken ; Production { lhs: 57, production: &[ParseType::N(59)], }, - // 231 - BaseLess: BaseLessToken : crate::veryl_token::VerylToken ; + // 235 - BaseLess: BaseLessToken : crate::veryl_token::VerylToken ; Production { lhs: 54, production: &[ParseType::N(56)], }, - // 232 - AllBit: AllBitToken : crate::veryl_token::VerylToken ; + // 236 - AllBit: AllBitToken : crate::veryl_token::VerylToken ; Production { lhs: 0, production: &[ParseType::N(2)], }, - // 233 - AssignmentOperator: AssignmentOperatorToken : crate::veryl_token::VerylToken ; + // 237 - AssignmentOperator: AssignmentOperatorToken : crate::veryl_token::VerylToken ; Production { lhs: 42, production: &[ParseType::N(44)], }, - // 234 - Operator01: Operator01Token : crate::veryl_token::VerylToken ; + // 238 - Operator01: Operator01Token : crate::veryl_token::VerylToken ; Production { - lhs: 427, - production: &[ParseType::N(429)], + lhs: 432, + production: &[ParseType::N(434)], }, - // 235 - Operator02: Operator02Token : crate::veryl_token::VerylToken ; + // 239 - Operator02: Operator02Token : crate::veryl_token::VerylToken ; Production { - lhs: 430, - production: &[ParseType::N(432)], + lhs: 435, + production: &[ParseType::N(437)], }, - // 236 - Operator03: Operator03Token : crate::veryl_token::VerylToken ; + // 240 - Operator03: Operator03Token : crate::veryl_token::VerylToken ; Production { - lhs: 433, - production: &[ParseType::N(435)], + lhs: 438, + production: &[ParseType::N(440)], }, - // 237 - Operator04: Operator04Token : crate::veryl_token::VerylToken ; + // 241 - Operator04: Operator04Token : crate::veryl_token::VerylToken ; Production { - lhs: 436, - production: &[ParseType::N(438)], + lhs: 441, + production: &[ParseType::N(443)], }, - // 238 - Operator05: Operator05Token : crate::veryl_token::VerylToken ; + // 242 - Operator05: Operator05Token : crate::veryl_token::VerylToken ; Production { - lhs: 439, - production: &[ParseType::N(441)], + lhs: 444, + production: &[ParseType::N(446)], }, - // 239 - Operator06: Operator06Token : crate::veryl_token::VerylToken ; + // 243 - Operator06: Operator06Token : crate::veryl_token::VerylToken ; Production { - lhs: 442, - production: &[ParseType::N(444)], + lhs: 447, + production: &[ParseType::N(449)], }, - // 240 - Operator07: Operator07Token : crate::veryl_token::VerylToken ; + // 244 - Operator07: Operator07Token : crate::veryl_token::VerylToken ; Production { - lhs: 445, - production: &[ParseType::N(447)], + lhs: 450, + production: &[ParseType::N(452)], }, - // 241 - Operator08: Operator08Token : crate::veryl_token::VerylToken ; + // 245 - Operator08: Operator08Token : crate::veryl_token::VerylToken ; Production { - lhs: 448, - production: &[ParseType::N(450)], + lhs: 453, + production: &[ParseType::N(455)], }, - // 242 - Operator09: Operator09Token : crate::veryl_token::VerylToken ; + // 246 - Operator09: Operator09Token : crate::veryl_token::VerylToken ; Production { - lhs: 451, - production: &[ParseType::N(453)], + lhs: 456, + production: &[ParseType::N(458)], }, - // 243 - Operator10: Operator10Token : crate::veryl_token::VerylToken ; + // 247 - Operator10: Operator10Token : crate::veryl_token::VerylToken ; Production { - lhs: 454, - production: &[ParseType::N(456)], + lhs: 459, + production: &[ParseType::N(461)], }, - // 244 - Operator11: Operator11Token : crate::veryl_token::VerylToken ; + // 248 - Operator11: Operator11Token : crate::veryl_token::VerylToken ; Production { - lhs: 457, - production: &[ParseType::N(459)], + lhs: 462, + production: &[ParseType::N(464)], }, - // 245 - UnaryOperator: UnaryOperatorToken : crate::veryl_token::VerylToken ; + // 249 - UnaryOperator: UnaryOperatorToken : crate::veryl_token::VerylToken ; Production { - lhs: 625, - production: &[ParseType::N(627)], + lhs: 638, + production: &[ParseType::N(640)], }, - // 246 - BackQuote: BackQuoteToken : crate::veryl_token::VerylToken ; + // 250 - BackQuote: BackQuoteToken : crate::veryl_token::VerylToken ; Production { lhs: 51, production: &[ParseType::N(53)], }, - // 247 - Colon: ColonToken : crate::veryl_token::VerylToken ; + // 251 - Colon: ColonToken : crate::veryl_token::VerylToken ; Production { lhs: 92, production: &[ParseType::N(100)], }, - // 248 - ColonColonLAngle: ColonColonLAngleToken : crate::veryl_token::VerylToken ; + // 252 - ColonColonLAngle: ColonColonLAngleToken : crate::veryl_token::VerylToken ; Production { lhs: 94, production: &[ParseType::N(96)], }, - // 249 - ColonColon: ColonColonToken : crate::veryl_token::VerylToken ; + // 253 - ColonColon: ColonColonToken : crate::veryl_token::VerylToken ; Production { lhs: 93, production: &[ParseType::N(98)], }, - // 250 - Comma: CommaToken : crate::veryl_token::VerylToken ; + // 254 - Comma: CommaToken : crate::veryl_token::VerylToken ; Production { lhs: 101, production: &[ParseType::N(103)], }, - // 251 - DotDot: DotDotToken : crate::veryl_token::VerylToken ; + // 255 - DotDot: DotDotToken : crate::veryl_token::VerylToken ; Production { - lhs: 125, - production: &[ParseType::N(130)], + lhs: 128, + production: &[ParseType::N(133)], }, - // 252 - DotDotEqu: DotDotEquToken : crate::veryl_token::VerylToken ; + // 256 - DotDotEqu: DotDotEquToken : crate::veryl_token::VerylToken ; Production { - lhs: 126, - production: &[ParseType::N(128)], + lhs: 129, + production: &[ParseType::N(131)], }, - // 253 - Dot: DotToken : crate::veryl_token::VerylToken ; + // 257 - Dot: DotToken : crate::veryl_token::VerylToken ; Production { - lhs: 124, - production: &[ParseType::N(132)], + lhs: 127, + production: &[ParseType::N(135)], }, - // 254 - Equ: EquToken : crate::veryl_token::VerylToken ; + // 258 - Equ: EquToken : crate::veryl_token::VerylToken ; Production { - lhs: 158, - production: &[ParseType::N(160)], + lhs: 161, + production: &[ParseType::N(163)], }, - // 255 - Hash: HashToken : crate::veryl_token::VerylToken ; + // 259 - Hash: HashToken : crate::veryl_token::VerylToken ; Production { - lhs: 237, - production: &[ParseType::N(239)], + lhs: 241, + production: &[ParseType::N(243)], }, - // 256 - QuoteLBrace: QuoteLBraceToken : crate::veryl_token::VerylToken ; + // 260 - QuoteLBrace: QuoteLBraceToken : crate::veryl_token::VerylToken ; Production { - lhs: 503, - production: &[ParseType::N(505)], + lhs: 515, + production: &[ParseType::N(517)], }, - // 257 - LAngle: LAngleToken : crate::veryl_token::VerylToken ; + // 261 - LAngle: LAngleToken : crate::veryl_token::VerylToken ; Production { - lhs: 352, - production: &[ParseType::N(354)], + lhs: 356, + production: &[ParseType::N(358)], }, - // 258 - LBrace: LBraceToken : crate::veryl_token::VerylToken ; + // 262 - LBrace: LBraceToken : crate::veryl_token::VerylToken ; Production { - lhs: 355, - production: &[ParseType::N(357)], + lhs: 359, + production: &[ParseType::N(361)], }, - // 259 - LBracket: LBracketToken : crate::veryl_token::VerylToken ; + // 263 - LBracket: LBracketToken : crate::veryl_token::VerylToken ; Production { - lhs: 358, - production: &[ParseType::N(360)], + lhs: 362, + production: &[ParseType::N(364)], }, - // 260 - LParen: LParenToken : crate::veryl_token::VerylToken ; + // 264 - LParen: LParenToken : crate::veryl_token::VerylToken ; Production { - lhs: 361, - production: &[ParseType::N(363)], + lhs: 365, + production: &[ParseType::N(367)], }, - // 261 - MinusColon: MinusColonToken : crate::veryl_token::VerylToken ; + // 265 - MinusColon: MinusColonToken : crate::veryl_token::VerylToken ; Production { - lhs: 382, - production: &[ParseType::N(384)], + lhs: 386, + production: &[ParseType::N(388)], }, - // 262 - MinusGT: MinusGTToken : crate::veryl_token::VerylToken ; + // 266 - MinusGT: MinusGTToken : crate::veryl_token::VerylToken ; Production { - lhs: 385, - production: &[ParseType::N(387)], + lhs: 389, + production: &[ParseType::N(391)], }, - // 263 - PlusColon: PlusColonToken : crate::veryl_token::VerylToken ; + // 267 - PlusColon: PlusColonToken : crate::veryl_token::VerylToken ; Production { - lhs: 482, - production: &[ParseType::N(484)], + lhs: 487, + production: &[ParseType::N(489)], }, - // 264 - RAngle: RAngleToken : crate::veryl_token::VerylToken ; + // 268 - RAngle: RAngleToken : crate::veryl_token::VerylToken ; Production { - lhs: 506, - production: &[ParseType::N(508)], + lhs: 518, + production: &[ParseType::N(520)], }, - // 265 - RBrace: RBraceToken : crate::veryl_token::VerylToken ; + // 269 - RBrace: RBraceToken : crate::veryl_token::VerylToken ; Production { - lhs: 509, - production: &[ParseType::N(511)], + lhs: 521, + production: &[ParseType::N(523)], }, - // 266 - RBracket: RBracketToken : crate::veryl_token::VerylToken ; + // 270 - RBracket: RBracketToken : crate::veryl_token::VerylToken ; Production { - lhs: 512, - production: &[ParseType::N(514)], + lhs: 524, + production: &[ParseType::N(526)], }, - // 267 - RParen: RParenToken : crate::veryl_token::VerylToken ; + // 271 - RParen: RParenToken : crate::veryl_token::VerylToken ; Production { - lhs: 515, - production: &[ParseType::N(517)], + lhs: 527, + production: &[ParseType::N(529)], }, - // 268 - Semicolon: SemicolonToken : crate::veryl_token::VerylToken ; + // 272 - Semicolon: SemicolonToken : crate::veryl_token::VerylToken ; Production { - lhs: 562, - production: &[ParseType::N(564)], + lhs: 575, + production: &[ParseType::N(577)], }, - // 269 - Star: StarToken : crate::veryl_token::VerylToken ; + // 273 - Star: StarToken : crate::veryl_token::VerylToken ; Production { - lhs: 568, - production: &[ParseType::N(570)], + lhs: 581, + production: &[ParseType::N(583)], }, - // 270 - AlwaysComb: AlwaysCombToken : crate::veryl_token::VerylToken ; + // 274 - AlwaysComb: AlwaysCombToken : crate::veryl_token::VerylToken ; Production { lhs: 5, production: &[ParseType::N(9)], }, - // 271 - AlwaysFf: AlwaysFfToken : crate::veryl_token::VerylToken ; + // 275 - AlwaysFf: AlwaysFfToken : crate::veryl_token::VerylToken ; Production { lhs: 10, production: &[ParseType::N(17)], }, - // 272 - As: AsToken : crate::veryl_token::VerylToken ; + // 276 - As: AsToken : crate::veryl_token::VerylToken ; Production { lhs: 33, production: &[ParseType::N(35)], }, - // 273 - Assign: AssignToken : crate::veryl_token::VerylToken ; + // 277 - Assign: AssignToken : crate::veryl_token::VerylToken ; Production { lhs: 36, production: &[ParseType::N(39)], }, - // 274 - Bit: BitToken : crate::veryl_token::VerylToken ; + // 278 - Bit: BitToken : crate::veryl_token::VerylToken ; Production { lhs: 60, production: &[ParseType::N(62)], }, - // 275 - Break: BreakToken : crate::veryl_token::VerylToken ; + // 279 - Break: BreakToken : crate::veryl_token::VerylToken ; Production { lhs: 63, production: &[ParseType::N(66)], }, - // 276 - Case: CaseToken : crate::veryl_token::VerylToken ; + // 280 - Case: CaseToken : crate::veryl_token::VerylToken ; Production { lhs: 67, production: &[ParseType::N(80)], }, - // 277 - Clock: ClockToken : crate::veryl_token::VerylToken ; + // 281 - Clock: ClockToken : crate::veryl_token::VerylToken ; Production { lhs: 82, production: &[ParseType::N(91)], }, - // 278 - ClockPosedge: ClockPosedgeToken : crate::veryl_token::VerylToken ; + // 282 - ClockPosedge: ClockPosedgeToken : crate::veryl_token::VerylToken ; Production { lhs: 87, production: &[ParseType::N(89)], }, - // 279 - ClockNegedge: ClockNegedgeToken : crate::veryl_token::VerylToken ; + // 283 - ClockNegedge: ClockNegedgeToken : crate::veryl_token::VerylToken ; Production { lhs: 84, production: &[ParseType::N(86)], }, - // 280 - Defaul: DefaultToken : crate::veryl_token::VerylToken ; + // 284 - Const: ConstToken : crate::veryl_token::VerylToken ; Production { lhs: 112, production: &[ParseType::N(114)], }, - // 281 - Else: ElseToken : crate::veryl_token::VerylToken ; + // 285 - Defaul: DefaultToken : crate::veryl_token::VerylToken ; Production { - lhs: 133, - production: &[ParseType::N(135)], + lhs: 115, + production: &[ParseType::N(117)], }, - // 282 - Embed: EmbedToken : crate::veryl_token::VerylToken ; + // 286 - Else: ElseToken : crate::veryl_token::VerylToken ; Production { lhs: 136, - production: &[ParseType::N(144)], + production: &[ParseType::N(138)], }, - // 283 - Enum: EnumToken : crate::veryl_token::VerylToken ; + // 287 - Embed: EmbedToken : crate::veryl_token::VerylToken ; Production { - lhs: 145, - production: &[ParseType::N(157)], + lhs: 139, + production: &[ParseType::N(147)], }, - // 284 - Export: ExportToken : crate::veryl_token::VerylToken ; + // 288 - Enum: EnumToken : crate::veryl_token::VerylToken ; Production { - lhs: 164, - production: &[ParseType::N(169)], + lhs: 148, + production: &[ParseType::N(160)], }, - // 285 - F32: F32Token : crate::veryl_token::VerylToken ; + // 289 - Export: ExportToken : crate::veryl_token::VerylToken ; Production { - lhs: 202, - production: &[ParseType::N(204)], + lhs: 167, + production: &[ParseType::N(172)], }, - // 286 - F64: F64Token : crate::veryl_token::VerylToken ; + // 290 - F32: F32Token : crate::veryl_token::VerylToken ; Production { lhs: 205, production: &[ParseType::N(207)], }, - // 287 - Final: FinalToken : crate::veryl_token::VerylToken ; + // 291 - F64: F64Token : crate::veryl_token::VerylToken ; Production { - lhs: 211, - production: &[ParseType::N(215)], + lhs: 208, + production: &[ParseType::N(210)], }, - // 288 - For: ForToken : crate::veryl_token::VerylToken ; + // 292 - Final: FinalToken : crate::veryl_token::VerylToken ; Production { - lhs: 220, - production: &[ParseType::N(225)], + lhs: 214, + production: &[ParseType::N(218)], }, - // 289 - Function: FunctionToken : crate::veryl_token::VerylToken ; + // 293 - For: ForToken : crate::veryl_token::VerylToken ; Production { - lhs: 226, - production: &[ParseType::N(236)], + lhs: 223, + production: &[ParseType::N(228)], }, - // 290 - I32: I32Token : crate::veryl_token::VerylToken ; + // 294 - Function: FunctionToken : crate::veryl_token::VerylToken ; Production { - lhs: 244, - production: &[ParseType::N(246)], + lhs: 229, + production: &[ParseType::N(239)], }, - // 291 - I64: I64Token : crate::veryl_token::VerylToken ; + // 295 - I32: I32Token : crate::veryl_token::VerylToken ; Production { - lhs: 247, - production: &[ParseType::N(249)], + lhs: 248, + production: &[ParseType::N(250)], }, - // 292 - If: IfToken : crate::veryl_token::VerylToken ; + // 296 - I64: I64Token : crate::veryl_token::VerylToken ; Production { - lhs: 255, - production: &[ParseType::N(274)], + lhs: 251, + production: &[ParseType::N(253)], }, - // 293 - IfReset: IfResetToken : crate::veryl_token::VerylToken ; + // 297 - If: IfToken : crate::veryl_token::VerylToken ; Production { - lhs: 258, - production: &[ParseType::N(266)], + lhs: 259, + production: &[ParseType::N(278)], }, - // 294 - Import: ImportToken : crate::veryl_token::VerylToken ; + // 298 - IfReset: IfResetToken : crate::veryl_token::VerylToken ; Production { - lhs: 275, - production: &[ParseType::N(279)], + lhs: 262, + production: &[ParseType::N(270)], }, - // 295 - In: InToken : crate::veryl_token::VerylToken ; + // 299 - Import: ImportToken : crate::veryl_token::VerylToken ; Production { - lhs: 280, - production: &[ParseType::N(282)], + lhs: 279, + production: &[ParseType::N(283)], }, - // 296 - Include: IncludeToken : crate::veryl_token::VerylToken ; + // 300 - In: InToken : crate::veryl_token::VerylToken ; Production { - lhs: 283, + lhs: 284, production: &[ParseType::N(286)], }, - // 297 - Initial: InitialToken : crate::veryl_token::VerylToken ; + // 301 - Include: IncludeToken : crate::veryl_token::VerylToken ; Production { lhs: 287, - production: &[ParseType::N(291)], + production: &[ParseType::N(290)], }, - // 298 - Inout: InoutToken : crate::veryl_token::VerylToken ; + // 302 - Initial: InitialToken : crate::veryl_token::VerylToken ; Production { - lhs: 292, - production: &[ParseType::N(294)], + lhs: 291, + production: &[ParseType::N(295)], }, - // 299 - Input: InputToken : crate::veryl_token::VerylToken ; + // 303 - Inout: InoutToken : crate::veryl_token::VerylToken ; Production { - lhs: 295, - production: &[ParseType::N(297)], + lhs: 296, + production: &[ParseType::N(298)], }, - // 300 - Inside: InsideToken : crate::veryl_token::VerylToken ; + // 304 - Input: InputToken : crate::veryl_token::VerylToken ; Production { - lhs: 298, + lhs: 299, production: &[ParseType::N(301)], }, - // 301 - Inst: InstToken : crate::veryl_token::VerylToken ; + // 305 - Inside: InsideToken : crate::veryl_token::VerylToken ; Production { lhs: 302, - production: &[ParseType::N(327)], + production: &[ParseType::N(305)], }, - // 302 - Interface: InterfaceToken : crate::veryl_token::VerylToken ; + // 306 - Inst: InstToken : crate::veryl_token::VerylToken ; Production { - lhs: 329, - production: &[ParseType::N(351)], + lhs: 306, + production: &[ParseType::N(331)], }, - // 303 - Let: LetToken : crate::veryl_token::VerylToken ; + // 307 - Interface: InterfaceToken : crate::veryl_token::VerylToken ; Production { - lhs: 364, - production: &[ParseType::N(370)], + lhs: 333, + production: &[ParseType::N(355)], }, - // 304 - Local: LocalToken : crate::veryl_token::VerylToken ; + // 308 - Let: LetToken : crate::veryl_token::VerylToken ; Production { - lhs: 371, - production: &[ParseType::N(375)], + lhs: 368, + production: &[ParseType::N(374)], }, - // 305 - Logic: LogicToken : crate::veryl_token::VerylToken ; + // 309 - Local: LocalToken : crate::veryl_token::VerylToken ; Production { - lhs: 376, - production: &[ParseType::N(378)], + lhs: 375, + production: &[ParseType::N(379)], }, - // 306 - Lsb: LsbToken : crate::veryl_token::VerylToken ; + // 310 - Logic: LogicToken : crate::veryl_token::VerylToken ; Production { - lhs: 379, - production: &[ParseType::N(381)], + lhs: 380, + production: &[ParseType::N(382)], }, - // 307 - Modport: ModportToken : crate::veryl_token::VerylToken ; + // 311 - Lsb: LsbToken : crate::veryl_token::VerylToken ; Production { - lhs: 388, - production: &[ParseType::N(398)], + lhs: 383, + production: &[ParseType::N(385)], }, - // 308 - Module: ModuleToken : crate::veryl_token::VerylToken ; + // 312 - Modport: ModportToken : crate::veryl_token::VerylToken ; Production { - lhs: 399, - production: &[ParseType::N(422)], + lhs: 392, + production: &[ParseType::N(402)], }, - // 309 - Msb: MsbToken : crate::veryl_token::VerylToken ; + // 313 - Module: ModuleToken : crate::veryl_token::VerylToken ; Production { - lhs: 423, - production: &[ParseType::N(425)], + lhs: 403, + production: &[ParseType::N(427)], }, - // 310 - Output: OutputToken : crate::veryl_token::VerylToken ; + // 314 - Msb: MsbToken : crate::veryl_token::VerylToken ; Production { - lhs: 460, - production: &[ParseType::N(462)], + lhs: 428, + production: &[ParseType::N(430)], }, - // 311 - Outside: OutsideToken : crate::veryl_token::VerylToken ; + // 315 - Output: OutputToken : crate::veryl_token::VerylToken ; Production { - lhs: 463, - production: &[ParseType::N(466)], + lhs: 465, + production: &[ParseType::N(467)], }, - // 312 - Package: PackageToken : crate::veryl_token::VerylToken ; + // 316 - Outside: OutsideToken : crate::veryl_token::VerylToken ; Production { - lhs: 467, - production: &[ParseType::N(478)], + lhs: 468, + production: &[ParseType::N(471)], }, - // 313 - Param: ParamToken : crate::veryl_token::VerylToken ; + // 317 - Package: PackageToken : crate::veryl_token::VerylToken ; Production { - lhs: 479, - production: &[ParseType::N(481)], + lhs: 472, + production: &[ParseType::N(483)], }, - // 314 - Pub: PubToken : crate::veryl_token::VerylToken ; + // 318 - Param: ParamToken : crate::veryl_token::VerylToken ; Production { - lhs: 500, - production: &[ParseType::N(502)], + lhs: 484, + production: &[ParseType::N(486)], }, - // 315 - Ref: RefToken : crate::veryl_token::VerylToken ; + // 319 - Proto: ProtoToken : crate::veryl_token::VerylToken ; Production { - lhs: 526, - production: &[ParseType::N(528)], + lhs: 505, + production: &[ParseType::N(511)], }, - // 316 - Repeat: RepeatToken : crate::veryl_token::VerylToken ; + // 320 - Pub: PubToken : crate::veryl_token::VerylToken ; Production { - lhs: 529, - production: &[ParseType::N(531)], + lhs: 512, + production: &[ParseType::N(514)], }, - // 317 - Reset: ResetToken : crate::veryl_token::VerylToken ; + // 321 - Ref: RefToken : crate::veryl_token::VerylToken ; Production { - lhs: 532, - production: &[ParseType::N(546)], + lhs: 538, + production: &[ParseType::N(540)], }, - // 318 - ResetAsyncHigh: ResetAsyncHighToken : crate::veryl_token::VerylToken ; + // 322 - Repeat: RepeatToken : crate::veryl_token::VerylToken ; Production { - lhs: 533, - production: &[ParseType::N(535)], + lhs: 541, + production: &[ParseType::N(543)], }, - // 319 - ResetAsyncLow: ResetAsyncLowToken : crate::veryl_token::VerylToken ; + // 323 - Reset: ResetToken : crate::veryl_token::VerylToken ; Production { - lhs: 536, - production: &[ParseType::N(538)], + lhs: 544, + production: &[ParseType::N(558)], }, - // 320 - ResetSyncHigh: ResetSyncHighToken : crate::veryl_token::VerylToken ; + // 324 - ResetAsyncHigh: ResetAsyncHighToken : crate::veryl_token::VerylToken ; Production { - lhs: 539, - production: &[ParseType::N(541)], + lhs: 545, + production: &[ParseType::N(547)], }, - // 321 - ResetSyncLow: ResetSyncLowToken : crate::veryl_token::VerylToken ; + // 325 - ResetAsyncLow: ResetAsyncLowToken : crate::veryl_token::VerylToken ; Production { - lhs: 542, - production: &[ParseType::N(544)], + lhs: 548, + production: &[ParseType::N(550)], }, - // 322 - Return: ReturnToken : crate::veryl_token::VerylToken ; + // 326 - ResetSyncHigh: ResetSyncHighToken : crate::veryl_token::VerylToken ; Production { - lhs: 547, - production: &[ParseType::N(550)], + lhs: 551, + production: &[ParseType::N(553)], }, - // 323 - Signed: SignedToken : crate::veryl_token::VerylToken ; + // 327 - ResetSyncLow: ResetSyncLowToken : crate::veryl_token::VerylToken ; Production { - lhs: 565, - production: &[ParseType::N(567)], + lhs: 554, + production: &[ParseType::N(556)], }, - // 324 - Step: StepToken : crate::veryl_token::VerylToken ; + // 328 - Return: ReturnToken : crate::veryl_token::VerylToken ; Production { - lhs: 574, - production: &[ParseType::N(576)], + lhs: 559, + production: &[ParseType::N(562)], }, - // 325 - Strin: StringToken : crate::veryl_token::VerylToken ; + // 329 - Signed: SignedToken : crate::veryl_token::VerylToken ; Production { - lhs: 577, - production: &[ParseType::N(582)], + lhs: 578, + production: &[ParseType::N(580)], }, - // 326 - Struct: StructToken : crate::veryl_token::VerylToken ; + // 330 - Step: StepToken : crate::veryl_token::VerylToken ; Production { - lhs: 583, - production: &[ParseType::N(585)], + lhs: 587, + production: &[ParseType::N(589)], + }, + // 331 - Strin: StringToken : crate::veryl_token::VerylToken ; + Production { + lhs: 590, + production: &[ParseType::N(595)], }, - // 327 - Switch: SwitchToken : crate::veryl_token::VerylToken ; + // 332 - Struct: StructToken : crate::veryl_token::VerylToken ; Production { lhs: 596, - production: &[ParseType::N(609)], + production: &[ParseType::N(598)], }, - // 328 - Tri: TriToken : crate::veryl_token::VerylToken ; + // 333 - Switch: SwitchToken : crate::veryl_token::VerylToken ; Production { - lhs: 610, - production: &[ParseType::N(612)], + lhs: 609, + production: &[ParseType::N(622)], }, - // 329 - Type: TypeToken : crate::veryl_token::VerylToken ; + // 334 - Tri: TriToken : crate::veryl_token::VerylToken ; Production { - lhs: 613, - production: &[ParseType::N(618)], + lhs: 623, + production: &[ParseType::N(625)], }, - // 330 - U32: U32Token : crate::veryl_token::VerylToken ; + // 335 - Type: TypeToken : crate::veryl_token::VerylToken ; Production { - lhs: 619, - production: &[ParseType::N(621)], + lhs: 626, + production: &[ParseType::N(631)], }, - // 331 - U64: U64Token : crate::veryl_token::VerylToken ; + // 336 - U32: U32Token : crate::veryl_token::VerylToken ; Production { - lhs: 622, - production: &[ParseType::N(624)], + lhs: 632, + production: &[ParseType::N(634)], }, - // 332 - Union: UnionToken : crate::veryl_token::VerylToken ; + // 337 - U64: U64Token : crate::veryl_token::VerylToken ; Production { - lhs: 628, - production: &[ParseType::N(630)], + lhs: 635, + production: &[ParseType::N(637)], }, - // 333 - Unsafe: UnsafeToken : crate::veryl_token::VerylToken ; + // 338 - Union: UnionToken : crate::veryl_token::VerylToken ; Production { - lhs: 631, - production: &[ParseType::N(635)], + lhs: 641, + production: &[ParseType::N(643)], }, - // 334 - Var: VarToken : crate::veryl_token::VerylToken ; + // 339 - Unsafe: UnsafeToken : crate::veryl_token::VerylToken ; Production { - lhs: 636, - production: &[ParseType::N(640)], + lhs: 644, + production: &[ParseType::N(648)], }, - // 335 - DollarIdentifier: DollarIdentifierToken : crate::veryl_token::VerylToken ; + // 340 - Var: VarToken : crate::veryl_token::VerylToken ; Production { - lhs: 121, - production: &[ParseType::N(123)], + lhs: 649, + production: &[ParseType::N(653)], }, - // 336 - Identifier: IdentifierToken : crate::veryl_token::VerylToken ; + // 341 - DollarIdentifier: DollarIdentifierToken : crate::veryl_token::VerylToken ; Production { - lhs: 250, - production: &[ParseType::N(254)], + lhs: 124, + production: &[ParseType::N(126)], }, - // 337 - Number: IntegralNumber; + // 342 - Identifier: IdentifierToken : crate::veryl_token::VerylToken ; Production { - lhs: 426, - production: &[ParseType::N(328)], + lhs: 254, + production: &[ParseType::N(258)], }, - // 338 - Number: RealNumber; + // 343 - Number: IntegralNumber; Production { - lhs: 426, - production: &[ParseType::N(525)], + lhs: 431, + production: &[ParseType::N(332)], }, - // 339 - IntegralNumber: Based; + // 344 - Number: RealNumber; Production { - lhs: 328, + lhs: 431, + production: &[ParseType::N(537)], + }, + // 345 - IntegralNumber: Based; + Production { + lhs: 332, production: &[ParseType::N(57)], }, - // 340 - IntegralNumber: BaseLess; + // 346 - IntegralNumber: BaseLess; Production { - lhs: 328, + lhs: 332, production: &[ParseType::N(54)], }, - // 341 - IntegralNumber: AllBit; + // 347 - IntegralNumber: AllBit; Production { - lhs: 328, + lhs: 332, production: &[ParseType::N(0)], }, - // 342 - RealNumber: FixedPoint; + // 348 - RealNumber: FixedPoint; Production { - lhs: 525, - production: &[ParseType::N(216)], + lhs: 537, + production: &[ParseType::N(219)], }, - // 343 - RealNumber: Exponent; + // 349 - RealNumber: Exponent; Production { - lhs: 525, - production: &[ParseType::N(161)], + lhs: 537, + production: &[ParseType::N(164)], }, - // 344 - HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; + // 350 - HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; Production { - lhs: 240, - production: &[ParseType::N(242), ParseType::N(241), ParseType::N(250)], + lhs: 244, + production: &[ParseType::N(246), ParseType::N(245), ParseType::N(254)], }, - // 345 - HierarchicalIdentifierList0: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; + // 351 - HierarchicalIdentifierList0: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; Production { - lhs: 242, + lhs: 246, production: &[ - ParseType::N(242), - ParseType::N(243), - ParseType::N(250), - ParseType::N(124), + ParseType::N(246), + ParseType::N(247), + ParseType::N(254), + ParseType::N(127), ], }, - // 346 - HierarchicalIdentifierList0List: Select HierarchicalIdentifierList0List; + // 352 - HierarchicalIdentifierList0List: Select HierarchicalIdentifierList0List; Production { - lhs: 243, - production: &[ParseType::N(243), ParseType::N(559)], + lhs: 247, + production: &[ParseType::N(247), ParseType::N(572)], }, - // 347 - HierarchicalIdentifierList0List: ; + // 353 - HierarchicalIdentifierList0List: ; Production { - lhs: 243, + lhs: 247, production: &[], }, - // 348 - HierarchicalIdentifierList0: ; + // 354 - HierarchicalIdentifierList0: ; Production { - lhs: 242, + lhs: 246, production: &[], }, - // 349 - HierarchicalIdentifierList: Select HierarchicalIdentifierList; + // 355 - HierarchicalIdentifierList: Select HierarchicalIdentifierList; Production { - lhs: 241, - production: &[ParseType::N(241), ParseType::N(559)], + lhs: 245, + production: &[ParseType::N(245), ParseType::N(572)], }, - // 350 - HierarchicalIdentifierList: ; + // 356 - HierarchicalIdentifierList: ; Production { - lhs: 241, + lhs: 245, production: &[], }, - // 351 - ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; + // 357 - ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; Production { - lhs: 554, - production: &[ParseType::N(556), ParseType::N(555)], + lhs: 567, + production: &[ParseType::N(569), ParseType::N(568)], }, - // 352 - ScopedIdentifierGroup: DollarIdentifier; + // 358 - ScopedIdentifierGroup: DollarIdentifier; Production { - lhs: 555, - production: &[ParseType::N(121)], + lhs: 568, + production: &[ParseType::N(124)], }, - // 353 - ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */; + // 359 - ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */; Production { - lhs: 555, - production: &[ParseType::N(557), ParseType::N(250)], + lhs: 568, + production: &[ParseType::N(570), ParseType::N(254)], }, - // 354 - ScopedIdentifierList: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList; + // 360 - ScopedIdentifierList: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList; Production { - lhs: 556, + lhs: 569, production: &[ - ParseType::N(556), - ParseType::N(558), - ParseType::N(250), + ParseType::N(569), + ParseType::N(571), + ParseType::N(254), ParseType::N(93), ], }, - // 355 - ScopedIdentifierList: ; + // 361 - ScopedIdentifierList: ; Production { - lhs: 556, + lhs: 569, production: &[], }, - // 356 - ScopedIdentifierOpt0: WithGenericArgument; + // 362 - ScopedIdentifierOpt0: WithGenericArgument; Production { - lhs: 558, - production: &[ParseType::N(648)], + lhs: 571, + production: &[ParseType::N(659)], }, - // 357 - ScopedIdentifierOpt0: ; + // 363 - ScopedIdentifierOpt0: ; Production { - lhs: 558, + lhs: 571, production: &[], }, - // 358 - ScopedIdentifierOpt: WithGenericArgument; + // 364 - ScopedIdentifierOpt: WithGenericArgument; Production { - lhs: 557, - production: &[ParseType::N(648)], + lhs: 570, + production: &[ParseType::N(659)], }, - // 359 - ScopedIdentifierOpt: ; + // 365 - ScopedIdentifierOpt: ; Production { - lhs: 557, + lhs: 570, production: &[], }, - // 360 - ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; + // 366 - ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; Production { - lhs: 197, - production: &[ParseType::N(199), ParseType::N(198), ParseType::N(554)], + lhs: 200, + production: &[ParseType::N(202), ParseType::N(201), ParseType::N(567)], }, - // 361 - ExpressionIdentifierList0: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; + // 367 - ExpressionIdentifierList0: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; Production { - lhs: 199, + lhs: 202, production: &[ - ParseType::N(199), - ParseType::N(200), - ParseType::N(250), - ParseType::N(124), + ParseType::N(202), + ParseType::N(203), + ParseType::N(254), + ParseType::N(127), ], }, - // 362 - ExpressionIdentifierList0List: Select ExpressionIdentifierList0List; - Production { - lhs: 200, - production: &[ParseType::N(200), ParseType::N(559)], - }, - // 363 - ExpressionIdentifierList0List: ; + // 368 - ExpressionIdentifierList0List: Select ExpressionIdentifierList0List; Production { - lhs: 200, - production: &[], + lhs: 203, + production: &[ParseType::N(203), ParseType::N(572)], }, - // 364 - ExpressionIdentifierList0: ; + // 369 - ExpressionIdentifierList0List: ; Production { - lhs: 199, + lhs: 203, production: &[], }, - // 365 - ExpressionIdentifierList: Select ExpressionIdentifierList; - Production { - lhs: 198, - production: &[ParseType::N(198), ParseType::N(559)], - }, - // 366 - ExpressionIdentifierList: ; + // 370 - ExpressionIdentifierList0: ; Production { - lhs: 198, + lhs: 202, production: &[], }, - // 367 - Expression: Expression01 ExpressionList /* Vec */; - Production { - lhs: 170, - production: &[ParseType::N(201), ParseType::N(171)], - }, - // 368 - ExpressionList: Operator01 Expression01 ExpressionList; + // 371 - ExpressionIdentifierList: Select ExpressionIdentifierList; Production { lhs: 201, - production: &[ParseType::N(201), ParseType::N(171), ParseType::N(427)], + production: &[ParseType::N(201), ParseType::N(572)], }, - // 369 - ExpressionList: ; + // 372 - ExpressionIdentifierList: ; Production { lhs: 201, production: &[], }, - // 370 - Expression01: Expression02 Expression01List /* Vec */; - Production { - lhs: 171, - production: &[ParseType::N(172), ParseType::N(173)], - }, - // 371 - Expression01List: Operator02 Expression02 Expression01List; + // 373 - Expression: Expression01 ExpressionList /* Vec */; Production { - lhs: 172, - production: &[ParseType::N(172), ParseType::N(173), ParseType::N(430)], + lhs: 173, + production: &[ParseType::N(204), ParseType::N(174)], }, - // 372 - Expression01List: ; + // 374 - ExpressionList: Operator01 Expression01 ExpressionList; Production { - lhs: 172, - production: &[], + lhs: 204, + production: &[ParseType::N(204), ParseType::N(174), ParseType::N(432)], }, - // 373 - Expression02: Expression03 Expression02List /* Vec */; + // 375 - ExpressionList: ; Production { - lhs: 173, - production: &[ParseType::N(174), ParseType::N(175)], + lhs: 204, + production: &[], }, - // 374 - Expression02List: Operator03 Expression03 Expression02List; + // 376 - Expression01: Expression02 Expression01List /* Vec */; Production { lhs: 174, - production: &[ParseType::N(174), ParseType::N(175), ParseType::N(433)], + production: &[ParseType::N(175), ParseType::N(176)], }, - // 375 - Expression02List: ; + // 377 - Expression01List: Operator02 Expression02 Expression01List; Production { - lhs: 174, - production: &[], + lhs: 175, + production: &[ParseType::N(175), ParseType::N(176), ParseType::N(435)], }, - // 376 - Expression03: Expression04 Expression03List /* Vec */; + // 378 - Expression01List: ; Production { lhs: 175, - production: &[ParseType::N(176), ParseType::N(177)], + production: &[], }, - // 377 - Expression03List: Operator04 Expression04 Expression03List; + // 379 - Expression02: Expression03 Expression02List /* Vec */; Production { lhs: 176, - production: &[ParseType::N(176), ParseType::N(177), ParseType::N(436)], + production: &[ParseType::N(177), ParseType::N(178)], }, - // 378 - Expression03List: ; + // 380 - Expression02List: Operator03 Expression03 Expression02List; Production { - lhs: 176, - production: &[], + lhs: 177, + production: &[ParseType::N(177), ParseType::N(178), ParseType::N(438)], }, - // 379 - Expression04: Expression05 Expression04List /* Vec */; + // 381 - Expression02List: ; Production { lhs: 177, - production: &[ParseType::N(178), ParseType::N(179)], + production: &[], }, - // 380 - Expression04List: Operator05 Expression05 Expression04List; + // 382 - Expression03: Expression04 Expression03List /* Vec */; Production { lhs: 178, - production: &[ParseType::N(178), ParseType::N(179), ParseType::N(439)], + production: &[ParseType::N(179), ParseType::N(180)], }, - // 381 - Expression04List: ; + // 383 - Expression03List: Operator04 Expression04 Expression03List; Production { - lhs: 178, - production: &[], + lhs: 179, + production: &[ParseType::N(179), ParseType::N(180), ParseType::N(441)], }, - // 382 - Expression05: Expression06 Expression05List /* Vec */; + // 384 - Expression03List: ; Production { lhs: 179, - production: &[ParseType::N(180), ParseType::N(181)], + production: &[], }, - // 383 - Expression05List: Operator06 Expression06 Expression05List; + // 385 - Expression04: Expression05 Expression04List /* Vec */; Production { lhs: 180, - production: &[ParseType::N(180), ParseType::N(181), ParseType::N(442)], + production: &[ParseType::N(181), ParseType::N(182)], }, - // 384 - Expression05List: ; + // 386 - Expression04List: Operator05 Expression05 Expression04List; Production { - lhs: 180, - production: &[], + lhs: 181, + production: &[ParseType::N(181), ParseType::N(182), ParseType::N(444)], }, - // 385 - Expression06: Expression07 Expression06List /* Vec */; + // 387 - Expression04List: ; Production { lhs: 181, - production: &[ParseType::N(182), ParseType::N(183)], + production: &[], }, - // 386 - Expression06List: Operator07 Expression07 Expression06List; + // 388 - Expression05: Expression06 Expression05List /* Vec */; Production { lhs: 182, - production: &[ParseType::N(182), ParseType::N(183), ParseType::N(445)], + production: &[ParseType::N(183), ParseType::N(184)], }, - // 387 - Expression06List: ; + // 389 - Expression05List: Operator06 Expression06 Expression05List; Production { - lhs: 182, - production: &[], + lhs: 183, + production: &[ParseType::N(183), ParseType::N(184), ParseType::N(447)], }, - // 388 - Expression07: Expression08 Expression07List /* Vec */; + // 390 - Expression05List: ; Production { lhs: 183, - production: &[ParseType::N(184), ParseType::N(185)], + production: &[], }, - // 389 - Expression07List: Operator08 Expression08 Expression07List; + // 391 - Expression06: Expression07 Expression06List /* Vec */; Production { lhs: 184, - production: &[ParseType::N(184), ParseType::N(185), ParseType::N(448)], + production: &[ParseType::N(185), ParseType::N(186)], }, - // 390 - Expression07List: ; + // 392 - Expression06List: Operator07 Expression07 Expression06List; Production { - lhs: 184, - production: &[], + lhs: 185, + production: &[ParseType::N(185), ParseType::N(186), ParseType::N(450)], }, - // 391 - Expression08: Expression09 Expression08List /* Vec */; + // 393 - Expression06List: ; Production { lhs: 185, - production: &[ParseType::N(186), ParseType::N(187)], + production: &[], }, - // 392 - Expression08List: Operator09 Expression09 Expression08List; + // 394 - Expression07: Expression08 Expression07List /* Vec */; Production { lhs: 186, - production: &[ParseType::N(186), ParseType::N(187), ParseType::N(451)], + production: &[ParseType::N(187), ParseType::N(188)], }, - // 393 - Expression08List: ; + // 395 - Expression07List: Operator08 Expression08 Expression07List; Production { - lhs: 186, - production: &[], + lhs: 187, + production: &[ParseType::N(187), ParseType::N(188), ParseType::N(453)], }, - // 394 - Expression09: Expression10 Expression09List /* Vec */; + // 396 - Expression07List: ; Production { lhs: 187, - production: &[ParseType::N(188), ParseType::N(190)], + production: &[], }, - // 395 - Expression09List: Expression09ListGroup Expression10 Expression09List; + // 397 - Expression08: Expression09 Expression08List /* Vec */; Production { lhs: 188, - production: &[ParseType::N(188), ParseType::N(190), ParseType::N(189)], + production: &[ParseType::N(189), ParseType::N(190)], }, - // 396 - Expression09ListGroup: Operator10; + // 398 - Expression08List: Operator09 Expression09 Expression08List; Production { lhs: 189, - production: &[ParseType::N(454)], + production: &[ParseType::N(189), ParseType::N(190), ParseType::N(456)], }, - // 397 - Expression09ListGroup: Star; + // 399 - Expression08List: ; Production { lhs: 189, - production: &[ParseType::N(568)], - }, - // 398 - Expression09List: ; - Production { - lhs: 188, production: &[], }, - // 399 - Expression10: Expression11 Expression10List /* Vec */; + // 400 - Expression09: Expression10 Expression09List /* Vec */; Production { lhs: 190, - production: &[ParseType::N(191), ParseType::N(192)], + production: &[ParseType::N(191), ParseType::N(193)], }, - // 400 - Expression10List: Operator11 Expression11 Expression10List; + // 401 - Expression09List: Expression09ListGroup Expression10 Expression09List; Production { lhs: 191, - production: &[ParseType::N(191), ParseType::N(192), ParseType::N(457)], + production: &[ParseType::N(191), ParseType::N(193), ParseType::N(192)], }, - // 401 - Expression10List: ; + // 402 - Expression09ListGroup: Operator10; Production { - lhs: 191, - production: &[], + lhs: 192, + production: &[ParseType::N(459)], }, - // 402 - Expression11: Expression12 Expression11Opt /* Option */; + // 403 - Expression09ListGroup: Star; Production { lhs: 192, - production: &[ParseType::N(193), ParseType::N(194)], + production: &[ParseType::N(581)], }, - // 403 - Expression11Opt: As CastingType; + // 404 - Expression09List: ; Production { - lhs: 193, - production: &[ParseType::N(81), ParseType::N(33)], + lhs: 191, + production: &[], }, - // 404 - Expression11Opt: ; + // 405 - Expression10: Expression11 Expression10List /* Vec */; Production { lhs: 193, - production: &[], + production: &[ParseType::N(194), ParseType::N(195)], }, - // 405 - Expression12: Expression12List /* Vec */ Factor; + // 406 - Expression10List: Operator11 Expression11 Expression10List; Production { lhs: 194, - production: &[ParseType::N(208), ParseType::N(195)], + production: &[ParseType::N(194), ParseType::N(195), ParseType::N(462)], + }, + // 407 - Expression10List: ; + Production { + lhs: 194, + production: &[], }, - // 406 - Expression12List: Expression12ListGroup Expression12List; + // 408 - Expression11: Expression12 Expression11Opt /* Option */; Production { lhs: 195, - production: &[ParseType::N(195), ParseType::N(196)], + production: &[ParseType::N(196), ParseType::N(197)], }, - // 407 - Expression12ListGroup: UnaryOperator; + // 409 - Expression11Opt: As CastingType; Production { lhs: 196, - production: &[ParseType::N(625)], + production: &[ParseType::N(81), ParseType::N(33)], }, - // 408 - Expression12ListGroup: Operator09; + // 410 - Expression11Opt: ; Production { lhs: 196, - production: &[ParseType::N(451)], + production: &[], }, - // 409 - Expression12ListGroup: Operator05; + // 411 - Expression12: Expression12List /* Vec */ Factor; Production { - lhs: 196, - production: &[ParseType::N(439)], + lhs: 197, + production: &[ParseType::N(211), ParseType::N(198)], }, - // 410 - Expression12ListGroup: Operator03; + // 412 - Expression12List: Expression12ListGroup Expression12List; Production { - lhs: 196, - production: &[ParseType::N(433)], + lhs: 198, + production: &[ParseType::N(198), ParseType::N(199)], }, - // 411 - Expression12ListGroup: Operator04; + // 413 - Expression12ListGroup: UnaryOperator; Production { - lhs: 196, - production: &[ParseType::N(436)], + lhs: 199, + production: &[ParseType::N(638)], }, - // 412 - Expression12List: ; + // 414 - Expression12ListGroup: Operator09; Production { - lhs: 195, + lhs: 199, + production: &[ParseType::N(456)], + }, + // 415 - Expression12ListGroup: Operator05; + Production { + lhs: 199, + production: &[ParseType::N(444)], + }, + // 416 - Expression12ListGroup: Operator03; + Production { + lhs: 199, + production: &[ParseType::N(438)], + }, + // 417 - Expression12ListGroup: Operator04; + Production { + lhs: 199, + production: &[ParseType::N(441)], + }, + // 418 - Expression12List: ; + Production { + lhs: 198, production: &[], }, - // 413 - Factor: Number; + // 419 - Factor: Number; Production { - lhs: 208, - production: &[ParseType::N(426)], + lhs: 211, + production: &[ParseType::N(431)], }, - // 414 - Factor: ExpressionIdentifier FactorOpt /* Option */; + // 420 - Factor: ExpressionIdentifier FactorOpt /* Option */; Production { - lhs: 208, - production: &[ParseType::N(210), ParseType::N(197)], + lhs: 211, + production: &[ParseType::N(213), ParseType::N(200)], }, - // 415 - Factor: LParen Expression RParen; + // 421 - Factor: LParen Expression RParen; Production { - lhs: 208, - production: &[ParseType::N(515), ParseType::N(170), ParseType::N(361)], + lhs: 211, + production: &[ParseType::N(527), ParseType::N(173), ParseType::N(365)], }, - // 416 - Factor: LBrace ConcatenationList RBrace; + // 422 - Factor: LBrace ConcatenationList RBrace; Production { - lhs: 208, - production: &[ParseType::N(509), ParseType::N(109), ParseType::N(355)], + lhs: 211, + production: &[ParseType::N(521), ParseType::N(109), ParseType::N(359)], }, - // 417 - Factor: QuoteLBrace ArrayLiteralList RBrace; + // 423 - Factor: QuoteLBrace ArrayLiteralList RBrace; Production { - lhs: 208, - production: &[ParseType::N(509), ParseType::N(28), ParseType::N(503)], + lhs: 211, + production: &[ParseType::N(521), ParseType::N(28), ParseType::N(515)], }, - // 418 - Factor: IfExpression; + // 424 - Factor: IfExpression; Production { - lhs: 208, - production: &[ParseType::N(256)], + lhs: 211, + production: &[ParseType::N(260)], }, - // 419 - Factor: CaseExpression; + // 425 - Factor: CaseExpression; Production { - lhs: 208, + lhs: 211, production: &[ParseType::N(70)], }, - // 420 - Factor: SwitchExpression; + // 426 - Factor: SwitchExpression; Production { - lhs: 208, - production: &[ParseType::N(599)], + lhs: 211, + production: &[ParseType::N(612)], }, - // 421 - Factor: StringLiteral; + // 427 - Factor: StringLiteral; Production { - lhs: 208, - production: &[ParseType::N(578)], + lhs: 211, + production: &[ParseType::N(591)], }, - // 422 - Factor: FactorGroup; + // 428 - Factor: FactorGroup; Production { - lhs: 208, - production: &[ParseType::N(209)], + lhs: 211, + production: &[ParseType::N(212)], }, - // 423 - FactorGroup: Msb; + // 429 - FactorGroup: Msb; Production { - lhs: 209, - production: &[ParseType::N(423)], + lhs: 212, + production: &[ParseType::N(428)], }, - // 424 - FactorGroup: Lsb; + // 430 - FactorGroup: Lsb; Production { - lhs: 209, - production: &[ParseType::N(379)], + lhs: 212, + production: &[ParseType::N(383)], }, - // 425 - Factor: InsideExpression; + // 431 - Factor: InsideExpression; Production { - lhs: 208, - production: &[ParseType::N(299)], + lhs: 211, + production: &[ParseType::N(303)], }, - // 426 - Factor: OutsideExpression; + // 432 - Factor: OutsideExpression; Production { - lhs: 208, - production: &[ParseType::N(464)], + lhs: 211, + production: &[ParseType::N(469)], }, - // 427 - FactorOpt: FunctionCall; + // 433 - FactorOpt: FunctionCall; Production { - lhs: 210, - production: &[ParseType::N(227)], + lhs: 213, + production: &[ParseType::N(230)], }, - // 428 - FactorOpt: ; + // 434 - FactorOpt: ; Production { - lhs: 210, + lhs: 213, production: &[], }, - // 429 - FunctionCall: LParen FunctionCallOpt /* Option */ RParen; + // 435 - FunctionCall: LParen FunctionCallOpt /* Option */ RParen; Production { - lhs: 227, - production: &[ParseType::N(515), ParseType::N(228), ParseType::N(361)], + lhs: 230, + production: &[ParseType::N(527), ParseType::N(231), ParseType::N(365)], }, - // 430 - FunctionCallOpt: ArgumentList; + // 436 - FunctionCallOpt: ArgumentList; Production { - lhs: 228, + lhs: 231, production: &[ParseType::N(20)], }, - // 431 - FunctionCallOpt: ; + // 437 - FunctionCallOpt: ; Production { - lhs: 228, + lhs: 231, production: &[], }, - // 432 - ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; + // 438 - ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; Production { lhs: 20, production: &[ParseType::N(22), ParseType::N(21), ParseType::N(19)], }, - // 433 - ArgumentListList: Comma ArgumentItem ArgumentListList; + // 439 - ArgumentListList: Comma ArgumentItem ArgumentListList; Production { lhs: 21, production: &[ParseType::N(21), ParseType::N(19), ParseType::N(101)], }, - // 434 - ArgumentListList: ; + // 440 - ArgumentListList: ; Production { lhs: 21, production: &[], }, - // 435 - ArgumentListOpt: Comma; + // 441 - ArgumentListOpt: Comma; Production { lhs: 22, production: &[ParseType::N(101)], }, - // 436 - ArgumentListOpt: ; + // 442 - ArgumentListOpt: ; Production { lhs: 22, production: &[], }, - // 437 - ArgumentItem: Expression; + // 443 - ArgumentItem: Expression; Production { lhs: 19, - production: &[ParseType::N(170)], + production: &[ParseType::N(173)], }, - // 438 - ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; + // 444 - ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; Production { lhs: 109, production: &[ParseType::N(111), ParseType::N(110), ParseType::N(107)], }, - // 439 - ConcatenationListList: Comma ConcatenationItem ConcatenationListList; + // 445 - ConcatenationListList: Comma ConcatenationItem ConcatenationListList; Production { lhs: 110, production: &[ParseType::N(110), ParseType::N(107), ParseType::N(101)], }, - // 440 - ConcatenationListList: ; + // 446 - ConcatenationListList: ; Production { lhs: 110, production: &[], }, - // 441 - ConcatenationListOpt: Comma; + // 447 - ConcatenationListOpt: Comma; Production { lhs: 111, production: &[ParseType::N(101)], }, - // 442 - ConcatenationListOpt: ; + // 448 - ConcatenationListOpt: ; Production { lhs: 111, production: &[], }, - // 443 - ConcatenationItem: Expression ConcatenationItemOpt /* Option */; + // 449 - ConcatenationItem: Expression ConcatenationItemOpt /* Option */; Production { lhs: 107, - production: &[ParseType::N(108), ParseType::N(170)], + production: &[ParseType::N(108), ParseType::N(173)], }, - // 444 - ConcatenationItemOpt: Repeat Expression; + // 450 - ConcatenationItemOpt: Repeat Expression; Production { lhs: 108, - production: &[ParseType::N(170), ParseType::N(529)], + production: &[ParseType::N(173), ParseType::N(541)], }, - // 445 - ConcatenationItemOpt: ; + // 451 - ConcatenationItemOpt: ; Production { lhs: 108, production: &[], }, - // 446 - ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; + // 452 - ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; Production { lhs: 28, production: &[ParseType::N(30), ParseType::N(29), ParseType::N(25)], }, - // 447 - ArrayLiteralListList: Comma ArrayLiteralItem ArrayLiteralListList; + // 453 - ArrayLiteralListList: Comma ArrayLiteralItem ArrayLiteralListList; Production { lhs: 29, production: &[ParseType::N(29), ParseType::N(25), ParseType::N(101)], }, - // 448 - ArrayLiteralListList: ; + // 454 - ArrayLiteralListList: ; Production { lhs: 29, production: &[], }, - // 449 - ArrayLiteralListOpt: Comma; + // 455 - ArrayLiteralListOpt: Comma; Production { lhs: 30, production: &[ParseType::N(101)], }, - // 450 - ArrayLiteralListOpt: ; + // 456 - ArrayLiteralListOpt: ; Production { lhs: 30, production: &[], }, - // 451 - ArrayLiteralItem: ArrayLiteralItemGroup; + // 457 - ArrayLiteralItem: ArrayLiteralItemGroup; Production { lhs: 25, production: &[ParseType::N(26)], }, - // 452 - ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; + // 458 - ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; Production { lhs: 26, - production: &[ParseType::N(27), ParseType::N(170)], + production: &[ParseType::N(27), ParseType::N(173)], }, - // 453 - ArrayLiteralItemGroup: Defaul Colon Expression; + // 459 - ArrayLiteralItemGroup: Defaul Colon Expression; Production { lhs: 26, - production: &[ParseType::N(170), ParseType::N(92), ParseType::N(112)], + production: &[ParseType::N(173), ParseType::N(92), ParseType::N(115)], }, - // 454 - ArrayLiteralItemOpt: Repeat Expression; + // 460 - ArrayLiteralItemOpt: Repeat Expression; Production { lhs: 27, - production: &[ParseType::N(170), ParseType::N(529)], + production: &[ParseType::N(173), ParseType::N(541)], }, - // 455 - ArrayLiteralItemOpt: ; + // 461 - ArrayLiteralItemOpt: ; Production { lhs: 27, production: &[], }, - // 456 - IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; + // 462 - IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; Production { - lhs: 256, + lhs: 260, production: &[ - ParseType::N(509), - ParseType::N(170), - ParseType::N(355), - ParseType::N(133), - ParseType::N(257), - ParseType::N(509), - ParseType::N(170), - ParseType::N(355), - ParseType::N(170), - ParseType::N(255), + ParseType::N(521), + ParseType::N(173), + ParseType::N(359), + ParseType::N(136), + ParseType::N(261), + ParseType::N(521), + ParseType::N(173), + ParseType::N(359), + ParseType::N(173), + ParseType::N(259), ], }, - // 457 - IfExpressionList: Else If Expression LBrace Expression RBrace IfExpressionList; + // 463 - IfExpressionList: Else If Expression LBrace Expression RBrace IfExpressionList; Production { - lhs: 257, + lhs: 261, production: &[ - ParseType::N(257), - ParseType::N(509), - ParseType::N(170), - ParseType::N(355), - ParseType::N(170), - ParseType::N(255), - ParseType::N(133), + ParseType::N(261), + ParseType::N(521), + ParseType::N(173), + ParseType::N(359), + ParseType::N(173), + ParseType::N(259), + ParseType::N(136), ], }, - // 458 - IfExpressionList: ; + // 464 - IfExpressionList: ; Production { - lhs: 257, + lhs: 261, production: &[], }, - // 459 - CaseExpression: Case Expression LBrace CaseCondition Colon Expression Comma CaseExpressionList /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; + // 465 - CaseExpression: Case Expression LBrace CaseCondition Colon Expression Comma CaseExpressionList /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; Production { lhs: 70, production: &[ - ParseType::N(509), + ParseType::N(521), ParseType::N(72), - ParseType::N(170), + ParseType::N(173), ParseType::N(92), - ParseType::N(112), + ParseType::N(115), ParseType::N(71), ParseType::N(101), - ParseType::N(170), + ParseType::N(173), ParseType::N(92), ParseType::N(68), - ParseType::N(355), - ParseType::N(170), + ParseType::N(359), + ParseType::N(173), ParseType::N(67), ], }, - // 460 - CaseExpressionList: CaseCondition Colon Expression Comma CaseExpressionList; + // 466 - CaseExpressionList: CaseCondition Colon Expression Comma CaseExpressionList; Production { lhs: 71, production: &[ ParseType::N(71), ParseType::N(101), - ParseType::N(170), + ParseType::N(173), ParseType::N(92), ParseType::N(68), ], }, - // 461 - CaseExpressionList: ; + // 467 - CaseExpressionList: ; Production { lhs: 71, production: &[], }, - // 462 - CaseExpressionOpt: Comma; + // 468 - CaseExpressionOpt: Comma; Production { lhs: 72, production: &[ParseType::N(101)], }, - // 463 - CaseExpressionOpt: ; + // 469 - CaseExpressionOpt: ; Production { lhs: 72, production: &[], }, - // 464 - SwitchExpression: Switch LBrace SwitchCondition Colon Expression Comma SwitchExpressionList /* Vec */ Defaul Colon Expression SwitchExpressionOpt /* Option */ RBrace; + // 470 - SwitchExpression: Switch LBrace SwitchCondition Colon Expression Comma SwitchExpressionList /* Vec */ Defaul Colon Expression SwitchExpressionOpt /* Option */ RBrace; Production { - lhs: 599, + lhs: 612, production: &[ - ParseType::N(509), - ParseType::N(601), - ParseType::N(170), + ParseType::N(521), + ParseType::N(614), + ParseType::N(173), ParseType::N(92), - ParseType::N(112), - ParseType::N(600), + ParseType::N(115), + ParseType::N(613), ParseType::N(101), - ParseType::N(170), + ParseType::N(173), ParseType::N(92), - ParseType::N(597), - ParseType::N(355), - ParseType::N(596), + ParseType::N(610), + ParseType::N(359), + ParseType::N(609), ], }, - // 465 - SwitchExpressionList: SwitchCondition Colon Expression Comma SwitchExpressionList; + // 471 - SwitchExpressionList: SwitchCondition Colon Expression Comma SwitchExpressionList; Production { - lhs: 600, + lhs: 613, production: &[ - ParseType::N(600), + ParseType::N(613), ParseType::N(101), - ParseType::N(170), + ParseType::N(173), ParseType::N(92), - ParseType::N(597), + ParseType::N(610), ], }, - // 466 - SwitchExpressionList: ; + // 472 - SwitchExpressionList: ; Production { - lhs: 600, + lhs: 613, production: &[], }, - // 467 - SwitchExpressionOpt: Comma; + // 473 - SwitchExpressionOpt: Comma; Production { - lhs: 601, + lhs: 614, production: &[ParseType::N(101)], }, - // 468 - SwitchExpressionOpt: ; + // 474 - SwitchExpressionOpt: ; Production { - lhs: 601, + lhs: 614, production: &[], }, - // 469 - TypeExpression: ScalarType; + // 475 - TypeExpression: ScalarType; Production { - lhs: 615, - production: &[ParseType::N(551)], + lhs: 628, + production: &[ParseType::N(563)], }, - // 470 - TypeExpression: Type LParen Expression RParen; + // 476 - TypeExpression: Type LParen Expression RParen; Production { - lhs: 615, + lhs: 628, production: &[ - ParseType::N(515), - ParseType::N(170), - ParseType::N(361), - ParseType::N(613), + ParseType::N(527), + ParseType::N(173), + ParseType::N(365), + ParseType::N(626), ], }, - // 471 - InsideExpression: Inside Expression LBrace RangeList RBrace; + // 477 - InsideExpression: Inside Expression LBrace RangeList RBrace; Production { - lhs: 299, + lhs: 303, production: &[ - ParseType::N(509), - ParseType::N(520), - ParseType::N(355), - ParseType::N(170), - ParseType::N(298), + ParseType::N(521), + ParseType::N(532), + ParseType::N(359), + ParseType::N(173), + ParseType::N(302), ], }, - // 472 - OutsideExpression: Outside Expression LBrace RangeList RBrace; + // 478 - OutsideExpression: Outside Expression LBrace RangeList RBrace; Production { - lhs: 464, + lhs: 469, production: &[ - ParseType::N(509), - ParseType::N(520), - ParseType::N(355), - ParseType::N(170), - ParseType::N(463), + ParseType::N(521), + ParseType::N(532), + ParseType::N(359), + ParseType::N(173), + ParseType::N(468), ], }, - // 473 - RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; + // 479 - RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; Production { - lhs: 520, - production: &[ParseType::N(522), ParseType::N(521), ParseType::N(519)], + lhs: 532, + production: &[ParseType::N(534), ParseType::N(533), ParseType::N(531)], }, - // 474 - RangeListList: Comma RangeItem RangeListList; + // 480 - RangeListList: Comma RangeItem RangeListList; Production { - lhs: 521, - production: &[ParseType::N(521), ParseType::N(519), ParseType::N(101)], + lhs: 533, + production: &[ParseType::N(533), ParseType::N(531), ParseType::N(101)], }, - // 475 - RangeListList: ; + // 481 - RangeListList: ; Production { - lhs: 521, + lhs: 533, production: &[], }, - // 476 - RangeListOpt: Comma; + // 482 - RangeListOpt: Comma; Production { - lhs: 522, + lhs: 534, production: &[ParseType::N(101)], }, - // 477 - RangeListOpt: ; + // 483 - RangeListOpt: ; Production { - lhs: 522, + lhs: 534, production: &[], }, - // 478 - RangeItem: Range; + // 484 - RangeItem: Range; Production { - lhs: 519, - production: &[ParseType::N(518)], + lhs: 531, + production: &[ParseType::N(530)], }, - // 479 - Select: LBracket Expression SelectOpt /* Option */ RBracket; + // 485 - Select: LBracket Expression SelectOpt /* Option */ RBracket; Production { - lhs: 559, + lhs: 572, production: &[ - ParseType::N(512), - ParseType::N(561), - ParseType::N(170), - ParseType::N(358), + ParseType::N(524), + ParseType::N(574), + ParseType::N(173), + ParseType::N(362), ], }, - // 480 - SelectOpt: SelectOperator Expression; + // 486 - SelectOpt: SelectOperator Expression; Production { - lhs: 561, - production: &[ParseType::N(170), ParseType::N(560)], + lhs: 574, + production: &[ParseType::N(173), ParseType::N(573)], }, - // 481 - SelectOpt: ; + // 487 - SelectOpt: ; Production { - lhs: 561, + lhs: 574, production: &[], }, - // 482 - SelectOperator: Colon; + // 488 - SelectOperator: Colon; Production { - lhs: 560, + lhs: 573, production: &[ParseType::N(92)], }, - // 483 - SelectOperator: PlusColon; + // 489 - SelectOperator: PlusColon; Production { - lhs: 560, - production: &[ParseType::N(482)], + lhs: 573, + production: &[ParseType::N(487)], }, - // 484 - SelectOperator: MinusColon; + // 490 - SelectOperator: MinusColon; Production { - lhs: 560, - production: &[ParseType::N(382)], + lhs: 573, + production: &[ParseType::N(386)], }, - // 485 - SelectOperator: Step; + // 491 - SelectOperator: Step; Production { - lhs: 560, - production: &[ParseType::N(574)], + lhs: 573, + production: &[ParseType::N(587)], }, - // 486 - Width: LAngle Expression WidthList /* Vec */ RAngle; + // 492 - Width: LAngle Expression WidthList /* Vec */ RAngle; Production { - lhs: 646, + lhs: 657, production: &[ - ParseType::N(506), - ParseType::N(647), - ParseType::N(170), - ParseType::N(352), + ParseType::N(518), + ParseType::N(658), + ParseType::N(173), + ParseType::N(356), ], }, - // 487 - WidthList: Comma Expression WidthList; + // 493 - WidthList: Comma Expression WidthList; Production { - lhs: 647, - production: &[ParseType::N(647), ParseType::N(170), ParseType::N(101)], + lhs: 658, + production: &[ParseType::N(658), ParseType::N(173), ParseType::N(101)], }, - // 488 - WidthList: ; + // 494 - WidthList: ; Production { - lhs: 647, + lhs: 658, production: &[], }, - // 489 - Array: LBracket Expression ArrayList /* Vec */ RBracket; + // 495 - Array: LBracket Expression ArrayList /* Vec */ RBracket; Production { lhs: 23, production: &[ - ParseType::N(512), + ParseType::N(524), ParseType::N(24), - ParseType::N(170), - ParseType::N(358), + ParseType::N(173), + ParseType::N(362), ], }, - // 490 - ArrayList: Comma Expression ArrayList; + // 496 - ArrayList: Comma Expression ArrayList; Production { lhs: 24, - production: &[ParseType::N(24), ParseType::N(170), ParseType::N(101)], + production: &[ParseType::N(24), ParseType::N(173), ParseType::N(101)], }, - // 491 - ArrayList: ; + // 497 - ArrayList: ; Production { lhs: 24, production: &[], }, - // 492 - Range: Expression RangeOpt /* Option */; + // 498 - Range: Expression RangeOpt /* Option */; Production { - lhs: 518, - production: &[ParseType::N(524), ParseType::N(170)], + lhs: 530, + production: &[ParseType::N(536), ParseType::N(173)], }, - // 493 - RangeOpt: RangeOperator Expression; + // 499 - RangeOpt: RangeOperator Expression; Production { - lhs: 524, - production: &[ParseType::N(170), ParseType::N(523)], + lhs: 536, + production: &[ParseType::N(173), ParseType::N(535)], }, - // 494 - RangeOpt: ; + // 500 - RangeOpt: ; Production { - lhs: 524, + lhs: 536, production: &[], }, - // 495 - RangeOperator: DotDot; + // 501 - RangeOperator: DotDot; Production { - lhs: 523, - production: &[ParseType::N(125)], - }, - // 496 - RangeOperator: DotDotEqu; - Production { - lhs: 523, - production: &[ParseType::N(126)], + lhs: 535, + production: &[ParseType::N(128)], }, - // 497 - FixedType: U32; + // 502 - RangeOperator: DotDotEqu; Production { - lhs: 219, - production: &[ParseType::N(619)], + lhs: 535, + production: &[ParseType::N(129)], }, - // 498 - FixedType: U64; + // 503 - FixedType: U32; Production { - lhs: 219, - production: &[ParseType::N(622)], + lhs: 222, + production: &[ParseType::N(632)], }, - // 499 - FixedType: I32; + // 504 - FixedType: U64; Production { - lhs: 219, - production: &[ParseType::N(244)], + lhs: 222, + production: &[ParseType::N(635)], }, - // 500 - FixedType: I64; + // 505 - FixedType: I32; Production { - lhs: 219, - production: &[ParseType::N(247)], + lhs: 222, + production: &[ParseType::N(248)], }, - // 501 - FixedType: F32; + // 506 - FixedType: I64; Production { - lhs: 219, - production: &[ParseType::N(202)], + lhs: 222, + production: &[ParseType::N(251)], }, - // 502 - FixedType: F64; + // 507 - FixedType: F32; Production { - lhs: 219, + lhs: 222, production: &[ParseType::N(205)], }, - // 503 - FixedType: Strin; + // 508 - FixedType: F64; Production { - lhs: 219, - production: &[ParseType::N(577)], + lhs: 222, + production: &[ParseType::N(208)], }, - // 504 - VariableType: VariableTypeGroup VariableTypeOpt /* Option */; + // 509 - FixedType: Strin; Production { - lhs: 641, - production: &[ParseType::N(643), ParseType::N(642)], + lhs: 222, + production: &[ParseType::N(590)], }, - // 505 - VariableTypeGroup: Clock; + // 510 - VariableType: Clock; Production { - lhs: 642, + lhs: 654, production: &[ParseType::N(82)], }, - // 506 - VariableTypeGroup: ClockPosedge; + // 511 - VariableType: ClockPosedge; Production { - lhs: 642, + lhs: 654, production: &[ParseType::N(87)], }, - // 507 - VariableTypeGroup: ClockNegedge; + // 512 - VariableType: ClockNegedge; Production { - lhs: 642, + lhs: 654, production: &[ParseType::N(84)], }, - // 508 - VariableTypeGroup: Reset; + // 513 - VariableType: Reset; Production { - lhs: 642, - production: &[ParseType::N(532)], + lhs: 654, + production: &[ParseType::N(544)], }, - // 509 - VariableTypeGroup: ResetAsyncHigh; + // 514 - VariableType: ResetAsyncHigh; Production { - lhs: 642, - production: &[ParseType::N(533)], + lhs: 654, + production: &[ParseType::N(545)], }, - // 510 - VariableTypeGroup: ResetAsyncLow; + // 515 - VariableType: ResetAsyncLow; Production { - lhs: 642, - production: &[ParseType::N(536)], + lhs: 654, + production: &[ParseType::N(548)], }, - // 511 - VariableTypeGroup: ResetSyncHigh; + // 516 - VariableType: ResetSyncHigh; Production { - lhs: 642, - production: &[ParseType::N(539)], + lhs: 654, + production: &[ParseType::N(551)], }, - // 512 - VariableTypeGroup: ResetSyncLow; + // 517 - VariableType: ResetSyncLow; Production { - lhs: 642, - production: &[ParseType::N(542)], + lhs: 654, + production: &[ParseType::N(554)], }, - // 513 - VariableTypeGroup: Logic; + // 518 - VariableType: Logic; Production { - lhs: 642, - production: &[ParseType::N(376)], + lhs: 654, + production: &[ParseType::N(380)], }, - // 514 - VariableTypeGroup: Bit; + // 519 - VariableType: Bit; Production { - lhs: 642, + lhs: 654, production: &[ParseType::N(60)], }, - // 515 - VariableTypeGroup: ScopedIdentifier; + // 520 - VariableType: ScopedIdentifier; Production { - lhs: 642, - production: &[ParseType::N(554)], + lhs: 654, + production: &[ParseType::N(567)], }, - // 516 - VariableTypeOpt: Width; + // 521 - TypeModifier: Tri; Production { - lhs: 643, - production: &[ParseType::N(646)], + lhs: 629, + production: &[ParseType::N(623)], }, - // 517 - VariableTypeOpt: ; + // 522 - TypeModifier: Signed; Production { - lhs: 643, - production: &[], + lhs: 629, + production: &[ParseType::N(578)], }, - // 518 - TypeModifier: Tri; + // 523 - ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; Production { - lhs: 616, - production: &[ParseType::N(610)], + lhs: 563, + production: &[ParseType::N(564), ParseType::N(565)], }, - // 519 - TypeModifier: Signed; + // 524 - ScalarTypeGroup: VariableType ScalarTypeOpt /* Option */; Production { - lhs: 616, - production: &[ParseType::N(565)], + lhs: 564, + production: &[ParseType::N(566), ParseType::N(654)], }, - // 520 - ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; + // 525 - ScalarTypeGroup: FixedType; Production { - lhs: 551, - production: &[ParseType::N(552), ParseType::N(553)], + lhs: 564, + production: &[ParseType::N(222)], }, - // 521 - ScalarTypeGroup: VariableType; + // 526 - ScalarTypeList: TypeModifier ScalarTypeList; Production { - lhs: 552, - production: &[ParseType::N(641)], + lhs: 565, + production: &[ParseType::N(565), ParseType::N(629)], }, - // 522 - ScalarTypeGroup: FixedType; + // 527 - ScalarTypeList: ; Production { - lhs: 552, - production: &[ParseType::N(219)], + lhs: 565, + production: &[], }, - // 523 - ScalarTypeList: TypeModifier ScalarTypeList; + // 528 - ScalarTypeOpt: Width; Production { - lhs: 553, - production: &[ParseType::N(553), ParseType::N(616)], + lhs: 566, + production: &[ParseType::N(657)], }, - // 524 - ScalarTypeList: ; + // 529 - ScalarTypeOpt: ; Production { - lhs: 553, + lhs: 566, production: &[], }, - // 525 - ArrayType: ScalarType ArrayTypeOpt /* Option */; + // 530 - ArrayType: ScalarType ArrayTypeOpt /* Option */; Production { lhs: 31, - production: &[ParseType::N(32), ParseType::N(551)], + production: &[ParseType::N(32), ParseType::N(563)], }, - // 526 - ArrayTypeOpt: Array; + // 531 - ArrayTypeOpt: Array; Production { lhs: 32, production: &[ParseType::N(23)], }, - // 527 - ArrayTypeOpt: ; + // 532 - ArrayTypeOpt: ; Production { lhs: 32, production: &[], }, - // 528 - CastingType: U32; + // 533 - CastingType: U32; Production { lhs: 81, - production: &[ParseType::N(619)], + production: &[ParseType::N(632)], }, - // 529 - CastingType: U64; + // 534 - CastingType: U64; Production { lhs: 81, - production: &[ParseType::N(622)], + production: &[ParseType::N(635)], }, - // 530 - CastingType: I32; + // 535 - CastingType: I32; Production { lhs: 81, - production: &[ParseType::N(244)], + production: &[ParseType::N(248)], }, - // 531 - CastingType: I64; + // 536 - CastingType: I64; Production { lhs: 81, - production: &[ParseType::N(247)], + production: &[ParseType::N(251)], }, - // 532 - CastingType: F32; + // 537 - CastingType: F32; Production { lhs: 81, - production: &[ParseType::N(202)], + production: &[ParseType::N(205)], }, - // 533 - CastingType: F64; + // 538 - CastingType: F64; Production { lhs: 81, - production: &[ParseType::N(205)], + production: &[ParseType::N(208)], }, - // 534 - CastingType: Clock; + // 539 - CastingType: Clock; Production { lhs: 81, production: &[ParseType::N(82)], }, - // 535 - CastingType: ClockPosedge; + // 540 - CastingType: ClockPosedge; Production { lhs: 81, production: &[ParseType::N(87)], }, - // 536 - CastingType: ClockNegedge; + // 541 - CastingType: ClockNegedge; Production { lhs: 81, production: &[ParseType::N(84)], }, - // 537 - CastingType: Reset; + // 542 - CastingType: Reset; Production { lhs: 81, - production: &[ParseType::N(532)], + production: &[ParseType::N(544)], }, - // 538 - CastingType: ResetAsyncHigh; + // 543 - CastingType: ResetAsyncHigh; Production { lhs: 81, - production: &[ParseType::N(533)], + production: &[ParseType::N(545)], }, - // 539 - CastingType: ResetAsyncLow; + // 544 - CastingType: ResetAsyncLow; Production { lhs: 81, - production: &[ParseType::N(536)], + production: &[ParseType::N(548)], }, - // 540 - CastingType: ResetSyncHigh; + // 545 - CastingType: ResetSyncHigh; Production { lhs: 81, - production: &[ParseType::N(539)], + production: &[ParseType::N(551)], }, - // 541 - CastingType: ResetSyncLow; + // 546 - CastingType: ResetSyncLow; Production { lhs: 81, - production: &[ParseType::N(542)], + production: &[ParseType::N(554)], }, - // 542 - CastingType: ScopedIdentifier; + // 547 - CastingType: ScopedIdentifier; Production { lhs: 81, - production: &[ParseType::N(554)], + production: &[ParseType::N(567)], }, - // 543 - ClockDomain: BackQuote Identifier; + // 548 - ClockDomain: BackQuote Identifier; Production { lhs: 83, - production: &[ParseType::N(250), ParseType::N(51)], + production: &[ParseType::N(254), ParseType::N(51)], }, - // 544 - Statement: LetStatement; + // 549 - Statement: LetStatement; Production { - lhs: 573, - production: &[ParseType::N(367)], + lhs: 586, + production: &[ParseType::N(371)], }, - // 545 - Statement: IdentifierStatement; + // 550 - Statement: IdentifierStatement; Production { - lhs: 573, - production: &[ParseType::N(251)], + lhs: 586, + production: &[ParseType::N(255)], }, - // 546 - Statement: IfStatement; + // 551 - Statement: IfStatement; Production { - lhs: 573, - production: &[ParseType::N(267)], + lhs: 586, + production: &[ParseType::N(271)], }, - // 547 - Statement: IfResetStatement; + // 552 - Statement: IfResetStatement; Production { - lhs: 573, - production: &[ParseType::N(259)], + lhs: 586, + production: &[ParseType::N(263)], }, - // 548 - Statement: ReturnStatement; + // 553 - Statement: ReturnStatement; Production { - lhs: 573, - production: &[ParseType::N(548)], + lhs: 586, + production: &[ParseType::N(560)], }, - // 549 - Statement: BreakStatement; + // 554 - Statement: BreakStatement; Production { - lhs: 573, + lhs: 586, production: &[ParseType::N(64)], }, - // 550 - Statement: ForStatement; + // 555 - Statement: ForStatement; Production { - lhs: 573, - production: &[ParseType::N(221)], + lhs: 586, + production: &[ParseType::N(224)], }, - // 551 - Statement: CaseStatement; + // 556 - Statement: CaseStatement; Production { - lhs: 573, + lhs: 586, production: &[ParseType::N(77)], }, - // 552 - Statement: SwitchStatement; + // 557 - Statement: SwitchStatement; Production { - lhs: 573, - production: &[ParseType::N(606)], + lhs: 586, + production: &[ParseType::N(619)], }, - // 553 - LetStatement: Let Identifier Colon LetStatementOpt /* Option */ ArrayType Equ Expression Semicolon; + // 558 - LetStatement: Let Identifier Colon LetStatementOpt /* Option */ ArrayType Equ Expression Semicolon; Production { - lhs: 367, + lhs: 371, production: &[ - ParseType::N(562), - ParseType::N(170), - ParseType::N(158), + ParseType::N(575), + ParseType::N(173), + ParseType::N(161), ParseType::N(31), - ParseType::N(368), + ParseType::N(372), ParseType::N(92), - ParseType::N(250), - ParseType::N(364), + ParseType::N(254), + ParseType::N(368), ], }, - // 554 - LetStatementOpt: ClockDomain; + // 559 - LetStatementOpt: ClockDomain; Production { - lhs: 368, + lhs: 372, production: &[ParseType::N(83)], }, - // 555 - LetStatementOpt: ; + // 560 - LetStatementOpt: ; Production { - lhs: 368, + lhs: 372, production: &[], }, - // 556 - IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; + // 561 - IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; Production { - lhs: 251, - production: &[ParseType::N(562), ParseType::N(252), ParseType::N(197)], + lhs: 255, + production: &[ParseType::N(575), ParseType::N(256), ParseType::N(200)], }, - // 557 - IdentifierStatementGroup: FunctionCall; + // 562 - IdentifierStatementGroup: FunctionCall; Production { - lhs: 252, - production: &[ParseType::N(227)], + lhs: 256, + production: &[ParseType::N(230)], }, - // 558 - IdentifierStatementGroup: Assignment; + // 563 - IdentifierStatementGroup: Assignment; Production { - lhs: 252, + lhs: 256, production: &[ParseType::N(40)], }, - // 559 - Assignment: AssignmentGroup Expression; + // 564 - Assignment: AssignmentGroup Expression; Production { lhs: 40, - production: &[ParseType::N(170), ParseType::N(41)], + production: &[ParseType::N(173), ParseType::N(41)], }, - // 560 - AssignmentGroup: Equ; + // 565 - AssignmentGroup: Equ; Production { lhs: 41, - production: &[ParseType::N(158)], + production: &[ParseType::N(161)], }, - // 561 - AssignmentGroup: AssignmentOperator; + // 566 - AssignmentGroup: AssignmentOperator; Production { lhs: 41, production: &[ParseType::N(42)], }, - // 562 - IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; + // 567 - IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; Production { - lhs: 267, + lhs: 271, production: &[ - ParseType::N(271), - ParseType::N(269), - ParseType::N(509), - ParseType::N(268), - ParseType::N(355), - ParseType::N(170), - ParseType::N(255), + ParseType::N(275), + ParseType::N(273), + ParseType::N(521), + ParseType::N(272), + ParseType::N(359), + ParseType::N(173), + ParseType::N(259), ], }, - // 563 - IfStatementList0: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; + // 568 - IfStatementList0: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; Production { - lhs: 269, + lhs: 273, production: &[ - ParseType::N(269), - ParseType::N(509), - ParseType::N(270), - ParseType::N(355), - ParseType::N(170), - ParseType::N(255), - ParseType::N(133), + ParseType::N(273), + ParseType::N(521), + ParseType::N(274), + ParseType::N(359), + ParseType::N(173), + ParseType::N(259), + ParseType::N(136), ], }, - // 564 - IfStatementList0List: Statement IfStatementList0List; + // 569 - IfStatementList0List: Statement IfStatementList0List; Production { - lhs: 270, - production: &[ParseType::N(270), ParseType::N(573)], + lhs: 274, + production: &[ParseType::N(274), ParseType::N(586)], }, - // 565 - IfStatementList0List: ; + // 570 - IfStatementList0List: ; Production { - lhs: 270, + lhs: 274, production: &[], }, - // 566 - IfStatementList0: ; + // 571 - IfStatementList0: ; Production { - lhs: 269, + lhs: 273, production: &[], }, - // 567 - IfStatementList: Statement IfStatementList; + // 572 - IfStatementList: Statement IfStatementList; Production { - lhs: 268, - production: &[ParseType::N(268), ParseType::N(573)], + lhs: 272, + production: &[ParseType::N(272), ParseType::N(586)], }, - // 568 - IfStatementList: ; + // 573 - IfStatementList: ; Production { - lhs: 268, + lhs: 272, production: &[], }, - // 569 - IfStatementOpt: Else LBrace IfStatementOptList /* Vec */ RBrace; + // 574 - IfStatementOpt: Else LBrace IfStatementOptList /* Vec */ RBrace; Production { - lhs: 271, + lhs: 275, production: &[ - ParseType::N(509), - ParseType::N(272), - ParseType::N(355), - ParseType::N(133), + ParseType::N(521), + ParseType::N(276), + ParseType::N(359), + ParseType::N(136), ], }, - // 570 - IfStatementOptList: Statement IfStatementOptList; + // 575 - IfStatementOptList: Statement IfStatementOptList; Production { - lhs: 272, - production: &[ParseType::N(272), ParseType::N(573)], + lhs: 276, + production: &[ParseType::N(276), ParseType::N(586)], }, - // 571 - IfStatementOptList: ; + // 576 - IfStatementOptList: ; Production { - lhs: 272, + lhs: 276, production: &[], }, - // 572 - IfStatementOpt: ; + // 577 - IfStatementOpt: ; Production { - lhs: 271, + lhs: 275, production: &[], }, - // 573 - IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; + // 578 - IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; Production { - lhs: 259, + lhs: 263, production: &[ - ParseType::N(263), - ParseType::N(261), - ParseType::N(509), - ParseType::N(260), - ParseType::N(355), - ParseType::N(258), + ParseType::N(267), + ParseType::N(265), + ParseType::N(521), + ParseType::N(264), + ParseType::N(359), + ParseType::N(262), ], }, - // 574 - IfResetStatementList0: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; + // 579 - IfResetStatementList0: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; Production { - lhs: 261, + lhs: 265, production: &[ - ParseType::N(261), - ParseType::N(509), - ParseType::N(262), - ParseType::N(355), - ParseType::N(170), - ParseType::N(255), - ParseType::N(133), + ParseType::N(265), + ParseType::N(521), + ParseType::N(266), + ParseType::N(359), + ParseType::N(173), + ParseType::N(259), + ParseType::N(136), ], }, - // 575 - IfResetStatementList0List: Statement IfResetStatementList0List; + // 580 - IfResetStatementList0List: Statement IfResetStatementList0List; Production { - lhs: 262, - production: &[ParseType::N(262), ParseType::N(573)], + lhs: 266, + production: &[ParseType::N(266), ParseType::N(586)], }, - // 576 - IfResetStatementList0List: ; + // 581 - IfResetStatementList0List: ; Production { - lhs: 262, + lhs: 266, production: &[], }, - // 577 - IfResetStatementList0: ; + // 582 - IfResetStatementList0: ; Production { - lhs: 261, + lhs: 265, production: &[], }, - // 578 - IfResetStatementList: Statement IfResetStatementList; + // 583 - IfResetStatementList: Statement IfResetStatementList; Production { - lhs: 260, - production: &[ParseType::N(260), ParseType::N(573)], + lhs: 264, + production: &[ParseType::N(264), ParseType::N(586)], }, - // 579 - IfResetStatementList: ; + // 584 - IfResetStatementList: ; Production { - lhs: 260, + lhs: 264, production: &[], }, - // 580 - IfResetStatementOpt: Else LBrace IfResetStatementOptList /* Vec */ RBrace; + // 585 - IfResetStatementOpt: Else LBrace IfResetStatementOptList /* Vec */ RBrace; Production { - lhs: 263, + lhs: 267, production: &[ - ParseType::N(509), - ParseType::N(264), - ParseType::N(355), - ParseType::N(133), + ParseType::N(521), + ParseType::N(268), + ParseType::N(359), + ParseType::N(136), ], }, - // 581 - IfResetStatementOptList: Statement IfResetStatementOptList; + // 586 - IfResetStatementOptList: Statement IfResetStatementOptList; Production { - lhs: 264, - production: &[ParseType::N(264), ParseType::N(573)], + lhs: 268, + production: &[ParseType::N(268), ParseType::N(586)], }, - // 582 - IfResetStatementOptList: ; + // 587 - IfResetStatementOptList: ; Production { - lhs: 264, + lhs: 268, production: &[], }, - // 583 - IfResetStatementOpt: ; + // 588 - IfResetStatementOpt: ; Production { - lhs: 263, + lhs: 267, production: &[], }, - // 584 - ReturnStatement: Return Expression Semicolon; + // 589 - ReturnStatement: Return Expression Semicolon; Production { - lhs: 548, - production: &[ParseType::N(562), ParseType::N(170), ParseType::N(547)], + lhs: 560, + production: &[ParseType::N(575), ParseType::N(173), ParseType::N(559)], }, - // 585 - BreakStatement: Break Semicolon; + // 590 - BreakStatement: Break Semicolon; Production { lhs: 64, - production: &[ParseType::N(562), ParseType::N(63)], + production: &[ParseType::N(575), ParseType::N(63)], }, - // 586 - ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; + // 591 - ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; Production { - lhs: 221, + lhs: 224, production: &[ - ParseType::N(509), - ParseType::N(222), - ParseType::N(355), - ParseType::N(223), - ParseType::N(518), - ParseType::N(280), - ParseType::N(551), + ParseType::N(521), + ParseType::N(225), + ParseType::N(359), + ParseType::N(226), + ParseType::N(530), + ParseType::N(284), + ParseType::N(563), ParseType::N(92), - ParseType::N(250), - ParseType::N(220), + ParseType::N(254), + ParseType::N(223), ], }, - // 587 - ForStatementList: Statement ForStatementList; + // 592 - ForStatementList: Statement ForStatementList; Production { - lhs: 222, - production: &[ParseType::N(222), ParseType::N(573)], + lhs: 225, + production: &[ParseType::N(225), ParseType::N(586)], }, - // 588 - ForStatementList: ; + // 593 - ForStatementList: ; Production { - lhs: 222, + lhs: 225, production: &[], }, - // 589 - ForStatementOpt: Step AssignmentOperator Expression; + // 594 - ForStatementOpt: Step AssignmentOperator Expression; Production { - lhs: 223, - production: &[ParseType::N(170), ParseType::N(42), ParseType::N(574)], + lhs: 226, + production: &[ParseType::N(173), ParseType::N(42), ParseType::N(587)], }, - // 590 - ForStatementOpt: ; + // 595 - ForStatementOpt: ; Production { - lhs: 223, + lhs: 226, production: &[], }, - // 591 - CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; + // 596 - CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; Production { lhs: 77, production: &[ - ParseType::N(509), + ParseType::N(521), ParseType::N(78), - ParseType::N(355), - ParseType::N(170), + ParseType::N(359), + ParseType::N(173), ParseType::N(67), ], }, - // 592 - CaseStatementList: CaseItem CaseStatementList; + // 597 - CaseStatementList: CaseItem CaseStatementList; Production { lhs: 78, production: &[ParseType::N(78), ParseType::N(73)], }, - // 593 - CaseStatementList: ; + // 598 - CaseStatementList: ; Production { lhs: 78, production: &[], }, - // 594 - CaseItem: CaseItemGroup Colon CaseItemGroup0; + // 599 - CaseItem: CaseItemGroup Colon CaseItemGroup0; Production { lhs: 73, production: &[ParseType::N(75), ParseType::N(92), ParseType::N(74)], }, - // 595 - CaseItemGroup0: Statement; + // 600 - CaseItemGroup0: Statement; Production { lhs: 75, - production: &[ParseType::N(573)], + production: &[ParseType::N(586)], }, - // 596 - CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; + // 601 - CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; Production { lhs: 75, - production: &[ParseType::N(509), ParseType::N(76), ParseType::N(355)], + production: &[ParseType::N(521), ParseType::N(76), ParseType::N(359)], }, - // 597 - CaseItemGroup0List: Statement CaseItemGroup0List; + // 602 - CaseItemGroup0List: Statement CaseItemGroup0List; Production { lhs: 76, - production: &[ParseType::N(76), ParseType::N(573)], + production: &[ParseType::N(76), ParseType::N(586)], }, - // 598 - CaseItemGroup0List: ; + // 603 - CaseItemGroup0List: ; Production { lhs: 76, production: &[], }, - // 599 - CaseItemGroup: CaseCondition; + // 604 - CaseItemGroup: CaseCondition; Production { lhs: 74, production: &[ParseType::N(68)], }, - // 600 - CaseItemGroup: Defaul; + // 605 - CaseItemGroup: Defaul; Production { lhs: 74, - production: &[ParseType::N(112)], + production: &[ParseType::N(115)], }, - // 601 - CaseCondition: RangeItem CaseConditionList /* Vec */; + // 606 - CaseCondition: RangeItem CaseConditionList /* Vec */; Production { lhs: 68, - production: &[ParseType::N(69), ParseType::N(519)], + production: &[ParseType::N(69), ParseType::N(531)], }, - // 602 - CaseConditionList: Comma RangeItem CaseConditionList; + // 607 - CaseConditionList: Comma RangeItem CaseConditionList; Production { lhs: 69, - production: &[ParseType::N(69), ParseType::N(519), ParseType::N(101)], + production: &[ParseType::N(69), ParseType::N(531), ParseType::N(101)], }, - // 603 - CaseConditionList: ; + // 608 - CaseConditionList: ; Production { lhs: 69, production: &[], }, - // 604 - SwitchStatement: Switch LBrace SwitchStatementList /* Vec */ RBrace; + // 609 - SwitchStatement: Switch LBrace SwitchStatementList /* Vec */ RBrace; Production { - lhs: 606, + lhs: 619, production: &[ - ParseType::N(509), - ParseType::N(607), - ParseType::N(355), - ParseType::N(596), + ParseType::N(521), + ParseType::N(620), + ParseType::N(359), + ParseType::N(609), ], }, - // 605 - SwitchStatementList: SwitchItem SwitchStatementList; + // 610 - SwitchStatementList: SwitchItem SwitchStatementList; Production { - lhs: 607, - production: &[ParseType::N(607), ParseType::N(602)], + lhs: 620, + production: &[ParseType::N(620), ParseType::N(615)], }, - // 606 - SwitchStatementList: ; + // 611 - SwitchStatementList: ; Production { - lhs: 607, + lhs: 620, production: &[], }, - // 607 - SwitchItem: SwitchItemGroup Colon SwitchItemGroup0; + // 612 - SwitchItem: SwitchItemGroup Colon SwitchItemGroup0; Production { - lhs: 602, - production: &[ParseType::N(604), ParseType::N(92), ParseType::N(603)], + lhs: 615, + production: &[ParseType::N(617), ParseType::N(92), ParseType::N(616)], }, - // 608 - SwitchItemGroup0: Statement; + // 613 - SwitchItemGroup0: Statement; Production { - lhs: 604, - production: &[ParseType::N(573)], + lhs: 617, + production: &[ParseType::N(586)], }, - // 609 - SwitchItemGroup0: LBrace SwitchItemGroup0List /* Vec */ RBrace; + // 614 - SwitchItemGroup0: LBrace SwitchItemGroup0List /* Vec */ RBrace; Production { - lhs: 604, - production: &[ParseType::N(509), ParseType::N(605), ParseType::N(355)], + lhs: 617, + production: &[ParseType::N(521), ParseType::N(618), ParseType::N(359)], }, - // 610 - SwitchItemGroup0List: Statement SwitchItemGroup0List; + // 615 - SwitchItemGroup0List: Statement SwitchItemGroup0List; Production { - lhs: 605, - production: &[ParseType::N(605), ParseType::N(573)], + lhs: 618, + production: &[ParseType::N(618), ParseType::N(586)], }, - // 611 - SwitchItemGroup0List: ; + // 616 - SwitchItemGroup0List: ; Production { - lhs: 605, + lhs: 618, production: &[], }, - // 612 - SwitchItemGroup: SwitchCondition; + // 617 - SwitchItemGroup: SwitchCondition; Production { - lhs: 603, - production: &[ParseType::N(597)], + lhs: 616, + production: &[ParseType::N(610)], }, - // 613 - SwitchItemGroup: Defaul; + // 618 - SwitchItemGroup: Defaul; Production { - lhs: 603, - production: &[ParseType::N(112)], + lhs: 616, + production: &[ParseType::N(115)], }, - // 614 - SwitchCondition: Expression SwitchConditionList /* Vec */; + // 619 - SwitchCondition: Expression SwitchConditionList /* Vec */; Production { - lhs: 597, - production: &[ParseType::N(598), ParseType::N(170)], + lhs: 610, + production: &[ParseType::N(611), ParseType::N(173)], }, - // 615 - SwitchConditionList: Comma Expression SwitchConditionList; + // 620 - SwitchConditionList: Comma Expression SwitchConditionList; Production { - lhs: 598, - production: &[ParseType::N(598), ParseType::N(170), ParseType::N(101)], + lhs: 611, + production: &[ParseType::N(611), ParseType::N(173), ParseType::N(101)], }, - // 616 - SwitchConditionList: ; + // 621 - SwitchConditionList: ; Production { - lhs: 598, + lhs: 611, production: &[], }, - // 617 - Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; + // 622 - Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; Production { lhs: 45, production: &[ - ParseType::N(512), + ParseType::N(524), ParseType::N(50), - ParseType::N(250), - ParseType::N(358), - ParseType::N(237), + ParseType::N(254), + ParseType::N(362), + ParseType::N(241), ], }, - // 618 - AttributeOpt: LParen AttributeList RParen; + // 623 - AttributeOpt: LParen AttributeList RParen; Production { lhs: 50, - production: &[ParseType::N(515), ParseType::N(47), ParseType::N(361)], + production: &[ParseType::N(527), ParseType::N(47), ParseType::N(365)], }, - // 619 - AttributeOpt: ; + // 624 - AttributeOpt: ; Production { lhs: 50, production: &[], }, - // 620 - AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; + // 625 - AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; Production { lhs: 47, production: &[ParseType::N(49), ParseType::N(48), ParseType::N(46)], }, - // 621 - AttributeListList: Comma AttributeItem AttributeListList; + // 626 - AttributeListList: Comma AttributeItem AttributeListList; Production { lhs: 48, production: &[ParseType::N(48), ParseType::N(46), ParseType::N(101)], }, - // 622 - AttributeListList: ; + // 627 - AttributeListList: ; Production { lhs: 48, production: &[], }, - // 623 - AttributeListOpt: Comma; + // 628 - AttributeListOpt: Comma; Production { lhs: 49, production: &[ParseType::N(101)], }, - // 624 - AttributeListOpt: ; + // 629 - AttributeListOpt: ; Production { lhs: 49, production: &[], }, - // 625 - AttributeItem: Identifier; + // 630 - AttributeItem: Identifier; Production { lhs: 46, - production: &[ParseType::N(250)], + production: &[ParseType::N(254)], }, - // 626 - AttributeItem: StringLiteral; + // 631 - AttributeItem: StringLiteral; Production { lhs: 46, - production: &[ParseType::N(578)], + production: &[ParseType::N(591)], }, - // 627 - LetDeclaration: Let Identifier Colon LetDeclarationOpt /* Option */ ArrayType Equ Expression Semicolon; + // 632 - LetDeclaration: Let Identifier Colon LetDeclarationOpt /* Option */ ArrayType Equ Expression Semicolon; Production { - lhs: 365, + lhs: 369, production: &[ - ParseType::N(562), - ParseType::N(170), - ParseType::N(158), + ParseType::N(575), + ParseType::N(173), + ParseType::N(161), ParseType::N(31), - ParseType::N(366), + ParseType::N(370), ParseType::N(92), - ParseType::N(250), - ParseType::N(364), + ParseType::N(254), + ParseType::N(368), ], }, - // 628 - LetDeclarationOpt: ClockDomain; + // 633 - LetDeclarationOpt: ClockDomain; Production { - lhs: 366, + lhs: 370, production: &[ParseType::N(83)], }, - // 629 - LetDeclarationOpt: ; + // 634 - LetDeclarationOpt: ; Production { - lhs: 366, + lhs: 370, production: &[], }, - // 630 - VarDeclaration: Var Identifier Colon VarDeclarationOpt /* Option */ ArrayType Semicolon; + // 635 - VarDeclaration: Var Identifier Colon VarDeclarationOpt /* Option */ ArrayType Semicolon; Production { - lhs: 637, + lhs: 650, production: &[ - ParseType::N(562), + ParseType::N(575), ParseType::N(31), - ParseType::N(638), + ParseType::N(651), ParseType::N(92), - ParseType::N(250), - ParseType::N(636), + ParseType::N(254), + ParseType::N(649), ], }, - // 631 - VarDeclarationOpt: ClockDomain; + // 636 - VarDeclarationOpt: ClockDomain; Production { - lhs: 638, + lhs: 651, production: &[ParseType::N(83)], }, - // 632 - VarDeclarationOpt: ; + // 637 - VarDeclarationOpt: ; Production { - lhs: 638, + lhs: 651, production: &[], }, - // 633 - LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; + // 638 - LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; Production { - lhs: 372, + lhs: 376, production: &[ - ParseType::N(562), - ParseType::N(373), + ParseType::N(575), + ParseType::N(377), ParseType::N(92), - ParseType::N(250), - ParseType::N(371), + ParseType::N(254), + ParseType::N(375), ], }, - // 634 - LocalDeclarationGroup: ArrayType Equ Expression; + // 639 - LocalDeclarationGroup: ArrayType Equ Expression; Production { - lhs: 373, - production: &[ParseType::N(170), ParseType::N(158), ParseType::N(31)], + lhs: 377, + production: &[ParseType::N(173), ParseType::N(161), ParseType::N(31)], }, - // 635 - LocalDeclarationGroup: Type Equ TypeExpression; + // 640 - LocalDeclarationGroup: Type Equ TypeExpression; Production { - lhs: 373, - production: &[ParseType::N(615), ParseType::N(158), ParseType::N(613)], + lhs: 377, + production: &[ParseType::N(628), ParseType::N(161), ParseType::N(626)], }, - // 636 - TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; + // 641 - TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; Production { - lhs: 614, + lhs: 627, production: &[ - ParseType::N(562), + ParseType::N(575), ParseType::N(31), - ParseType::N(158), - ParseType::N(250), - ParseType::N(613), + ParseType::N(161), + ParseType::N(254), + ParseType::N(626), ], }, - // 637 - AlwaysFfDeclaration: AlwaysFf AlwaysFfDeclarationOpt /* Option */ LBrace AlwaysFfDeclarationList /* Vec */ RBrace; + // 642 - AlwaysFfDeclaration: AlwaysFf AlwaysFfDeclarationOpt /* Option */ LBrace AlwaysFfDeclarationList /* Vec */ RBrace; Production { lhs: 12, production: &[ - ParseType::N(509), + ParseType::N(521), ParseType::N(13), - ParseType::N(355), + ParseType::N(359), ParseType::N(14), ParseType::N(10), ], }, - // 638 - AlwaysFfDeclarationList: Statement AlwaysFfDeclarationList; + // 643 - AlwaysFfDeclarationList: Statement AlwaysFfDeclarationList; Production { lhs: 13, - production: &[ParseType::N(13), ParseType::N(573)], + production: &[ParseType::N(13), ParseType::N(586)], }, - // 639 - AlwaysFfDeclarationList: ; + // 644 - AlwaysFfDeclarationList: ; Production { lhs: 13, production: &[], }, - // 640 - AlwaysFfDeclarationOpt: AlwayfFfEventList; + // 645 - AlwaysFfDeclarationOpt: AlwayfFfEventList; Production { lhs: 14, production: &[ParseType::N(3)], }, - // 641 - AlwaysFfDeclarationOpt: ; + // 646 - AlwaysFfDeclarationOpt: ; Production { lhs: 14, production: &[], }, - // 642 - AlwayfFfEventList: LParen AlwaysFfClock AlwayfFfEventListOpt /* Option */ RParen; + // 647 - AlwayfFfEventList: LParen AlwaysFfClock AlwayfFfEventListOpt /* Option */ RParen; Production { lhs: 3, production: &[ - ParseType::N(515), + ParseType::N(527), ParseType::N(4), ParseType::N(11), - ParseType::N(361), + ParseType::N(365), ], }, - // 643 - AlwayfFfEventListOpt: Comma AlwaysFfReset; + // 648 - AlwayfFfEventListOpt: Comma AlwaysFfReset; Production { lhs: 4, production: &[ParseType::N(15), ParseType::N(101)], }, - // 644 - AlwayfFfEventListOpt: ; + // 649 - AlwayfFfEventListOpt: ; Production { lhs: 4, production: &[], }, - // 645 - AlwaysFfClock: HierarchicalIdentifier; + // 650 - AlwaysFfClock: HierarchicalIdentifier; Production { lhs: 11, - production: &[ParseType::N(240)], + production: &[ParseType::N(244)], }, - // 646 - AlwaysFfReset: HierarchicalIdentifier; + // 651 - AlwaysFfReset: HierarchicalIdentifier; Production { lhs: 15, - production: &[ParseType::N(240)], + production: &[ParseType::N(244)], }, - // 647 - AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; + // 652 - AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; Production { lhs: 6, production: &[ - ParseType::N(509), + ParseType::N(521), ParseType::N(7), - ParseType::N(355), + ParseType::N(359), ParseType::N(5), ], }, - // 648 - AlwaysCombDeclarationList: Statement AlwaysCombDeclarationList; + // 653 - AlwaysCombDeclarationList: Statement AlwaysCombDeclarationList; Production { lhs: 7, - production: &[ParseType::N(7), ParseType::N(573)], + production: &[ParseType::N(7), ParseType::N(586)], }, - // 649 - AlwaysCombDeclarationList: ; + // 654 - AlwaysCombDeclarationList: ; Production { lhs: 7, production: &[], }, - // 650 - AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; + // 655 - AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; Production { lhs: 37, production: &[ - ParseType::N(562), - ParseType::N(170), - ParseType::N(158), - ParseType::N(240), + ParseType::N(575), + ParseType::N(173), + ParseType::N(161), + ParseType::N(244), ParseType::N(36), ], }, - // 651 - ModportDeclaration: Modport Identifier LBrace ModportList RBrace; + // 656 - ModportDeclaration: Modport Identifier LBrace ModportList RBrace; Production { - lhs: 389, + lhs: 393, production: &[ - ParseType::N(509), - ParseType::N(394), - ParseType::N(355), - ParseType::N(250), - ParseType::N(388), + ParseType::N(521), + ParseType::N(398), + ParseType::N(359), + ParseType::N(254), + ParseType::N(392), ], }, - // 652 - ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; + // 657 - ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; Production { - lhs: 394, - production: &[ParseType::N(396), ParseType::N(395), ParseType::N(390)], + lhs: 398, + production: &[ParseType::N(400), ParseType::N(399), ParseType::N(394)], }, - // 653 - ModportListList: Comma ModportGroup ModportListList; + // 658 - ModportListList: Comma ModportGroup ModportListList; Production { - lhs: 395, - production: &[ParseType::N(395), ParseType::N(390), ParseType::N(101)], + lhs: 399, + production: &[ParseType::N(399), ParseType::N(394), ParseType::N(101)], }, - // 654 - ModportListList: ; + // 659 - ModportListList: ; Production { - lhs: 395, + lhs: 399, production: &[], }, - // 655 - ModportListOpt: Comma; + // 660 - ModportListOpt: Comma; Production { - lhs: 396, + lhs: 400, production: &[ParseType::N(101)], }, - // 656 - ModportListOpt: ; + // 661 - ModportListOpt: ; Production { - lhs: 396, + lhs: 400, production: &[], }, - // 657 - ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; + // 662 - ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; Production { - lhs: 390, - production: &[ParseType::N(391), ParseType::N(392)], + lhs: 394, + production: &[ParseType::N(395), ParseType::N(396)], }, - // 658 - ModportGroupGroup: LBrace ModportList RBrace; + // 663 - ModportGroupGroup: LBrace ModportList RBrace; Production { - lhs: 391, - production: &[ParseType::N(509), ParseType::N(394), ParseType::N(355)], + lhs: 395, + production: &[ParseType::N(521), ParseType::N(398), ParseType::N(359)], }, - // 659 - ModportGroupGroup: ModportItem; + // 664 - ModportGroupGroup: ModportItem; Production { - lhs: 391, - production: &[ParseType::N(393)], + lhs: 395, + production: &[ParseType::N(397)], }, - // 660 - ModportGroupList: Attribute ModportGroupList; + // 665 - ModportGroupList: Attribute ModportGroupList; Production { - lhs: 392, - production: &[ParseType::N(392), ParseType::N(45)], + lhs: 396, + production: &[ParseType::N(396), ParseType::N(45)], }, - // 661 - ModportGroupList: ; + // 666 - ModportGroupList: ; Production { - lhs: 392, + lhs: 396, production: &[], }, - // 662 - ModportItem: Identifier Colon Direction; + // 667 - ModportItem: Identifier Colon Direction; Production { - lhs: 393, - production: &[ParseType::N(120), ParseType::N(92), ParseType::N(250)], + lhs: 397, + production: &[ParseType::N(123), ParseType::N(92), ParseType::N(254)], }, - // 663 - EnumDeclaration: Enum Identifier EnumDeclarationOpt /* Option */ LBrace EnumList RBrace; + // 668 - EnumDeclaration: Enum Identifier EnumDeclarationOpt /* Option */ LBrace EnumList RBrace; Production { - lhs: 146, + lhs: 149, production: &[ - ParseType::N(509), - ParseType::N(153), - ParseType::N(355), - ParseType::N(147), - ParseType::N(250), - ParseType::N(145), + ParseType::N(521), + ParseType::N(156), + ParseType::N(359), + ParseType::N(150), + ParseType::N(254), + ParseType::N(148), ], }, - // 664 - EnumDeclarationOpt: Colon ScalarType; + // 669 - EnumDeclarationOpt: Colon ScalarType; Production { - lhs: 147, - production: &[ParseType::N(551), ParseType::N(92)], + lhs: 150, + production: &[ParseType::N(563), ParseType::N(92)], }, - // 665 - EnumDeclarationOpt: ; + // 670 - EnumDeclarationOpt: ; Production { - lhs: 147, + lhs: 150, production: &[], }, - // 666 - EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; + // 671 - EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; Production { - lhs: 153, - production: &[ParseType::N(155), ParseType::N(154), ParseType::N(148)], + lhs: 156, + production: &[ParseType::N(158), ParseType::N(157), ParseType::N(151)], }, - // 667 - EnumListList: Comma EnumGroup EnumListList; + // 672 - EnumListList: Comma EnumGroup EnumListList; Production { - lhs: 154, - production: &[ParseType::N(154), ParseType::N(148), ParseType::N(101)], + lhs: 157, + production: &[ParseType::N(157), ParseType::N(151), ParseType::N(101)], }, - // 668 - EnumListList: ; + // 673 - EnumListList: ; Production { - lhs: 154, + lhs: 157, production: &[], }, - // 669 - EnumListOpt: Comma; + // 674 - EnumListOpt: Comma; Production { - lhs: 155, + lhs: 158, production: &[ParseType::N(101)], }, - // 670 - EnumListOpt: ; + // 675 - EnumListOpt: ; Production { - lhs: 155, + lhs: 158, production: &[], }, - // 671 - EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; + // 676 - EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; Production { - lhs: 148, - production: &[ParseType::N(149), ParseType::N(150)], + lhs: 151, + production: &[ParseType::N(152), ParseType::N(153)], }, - // 672 - EnumGroupGroup: LBrace EnumList RBrace; + // 677 - EnumGroupGroup: LBrace EnumList RBrace; Production { - lhs: 149, - production: &[ParseType::N(509), ParseType::N(153), ParseType::N(355)], + lhs: 152, + production: &[ParseType::N(521), ParseType::N(156), ParseType::N(359)], }, - // 673 - EnumGroupGroup: EnumItem; + // 678 - EnumGroupGroup: EnumItem; Production { - lhs: 149, - production: &[ParseType::N(151)], + lhs: 152, + production: &[ParseType::N(154)], }, - // 674 - EnumGroupList: Attribute EnumGroupList; + // 679 - EnumGroupList: Attribute EnumGroupList; Production { - lhs: 150, - production: &[ParseType::N(150), ParseType::N(45)], + lhs: 153, + production: &[ParseType::N(153), ParseType::N(45)], }, - // 675 - EnumGroupList: ; + // 680 - EnumGroupList: ; Production { - lhs: 150, + lhs: 153, production: &[], }, - // 676 - EnumItem: Identifier EnumItemOpt /* Option */; + // 681 - EnumItem: Identifier EnumItemOpt /* Option */; Production { - lhs: 151, - production: &[ParseType::N(152), ParseType::N(250)], + lhs: 154, + production: &[ParseType::N(155), ParseType::N(254)], }, - // 677 - EnumItemOpt: Equ Expression; + // 682 - EnumItemOpt: Equ Expression; Production { - lhs: 152, - production: &[ParseType::N(170), ParseType::N(158)], + lhs: 155, + production: &[ParseType::N(173), ParseType::N(161)], }, - // 678 - EnumItemOpt: ; + // 683 - EnumItemOpt: ; Production { - lhs: 152, + lhs: 155, production: &[], }, - // 679 - StructUnion: Struct; + // 684 - StructUnion: Struct; Production { - lhs: 586, - production: &[ParseType::N(583)], + lhs: 599, + production: &[ParseType::N(596)], }, - // 680 - StructUnion: Union; + // 685 - StructUnion: Union; Production { - lhs: 586, - production: &[ParseType::N(628)], + lhs: 599, + production: &[ParseType::N(641)], }, - // 681 - StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace; + // 686 - StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace; Production { - lhs: 587, + lhs: 600, production: &[ - ParseType::N(509), - ParseType::N(593), - ParseType::N(355), - ParseType::N(588), - ParseType::N(250), - ParseType::N(586), + ParseType::N(521), + ParseType::N(606), + ParseType::N(359), + ParseType::N(601), + ParseType::N(254), + ParseType::N(599), ], }, - // 682 - StructUnionDeclarationOpt: WithGenericParameter; + // 687 - StructUnionDeclarationOpt: WithGenericParameter; Production { - lhs: 588, - production: &[ParseType::N(654)], + lhs: 601, + production: &[ParseType::N(665)], }, - // 683 - StructUnionDeclarationOpt: ; + // 688 - StructUnionDeclarationOpt: ; Production { - lhs: 588, + lhs: 601, production: &[], }, - // 684 - StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; + // 689 - StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; Production { - lhs: 593, - production: &[ParseType::N(595), ParseType::N(594), ParseType::N(589)], + lhs: 606, + production: &[ParseType::N(608), ParseType::N(607), ParseType::N(602)], }, - // 685 - StructUnionListList: Comma StructUnionGroup StructUnionListList; + // 690 - StructUnionListList: Comma StructUnionGroup StructUnionListList; Production { - lhs: 594, - production: &[ParseType::N(594), ParseType::N(589), ParseType::N(101)], + lhs: 607, + production: &[ParseType::N(607), ParseType::N(602), ParseType::N(101)], }, - // 686 - StructUnionListList: ; + // 691 - StructUnionListList: ; Production { - lhs: 594, + lhs: 607, production: &[], }, - // 687 - StructUnionListOpt: Comma; + // 692 - StructUnionListOpt: Comma; Production { - lhs: 595, + lhs: 608, production: &[ParseType::N(101)], }, - // 688 - StructUnionListOpt: ; + // 693 - StructUnionListOpt: ; Production { - lhs: 595, + lhs: 608, production: &[], }, - // 689 - StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; + // 694 - StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; Production { - lhs: 589, - production: &[ParseType::N(590), ParseType::N(591)], + lhs: 602, + production: &[ParseType::N(603), ParseType::N(604)], }, - // 690 - StructUnionGroupGroup: LBrace StructUnionList RBrace; + // 695 - StructUnionGroupGroup: LBrace StructUnionList RBrace; Production { - lhs: 590, - production: &[ParseType::N(509), ParseType::N(593), ParseType::N(355)], + lhs: 603, + production: &[ParseType::N(521), ParseType::N(606), ParseType::N(359)], }, - // 691 - StructUnionGroupGroup: StructUnionItem; + // 696 - StructUnionGroupGroup: StructUnionItem; Production { - lhs: 590, - production: &[ParseType::N(592)], + lhs: 603, + production: &[ParseType::N(605)], }, - // 692 - StructUnionGroupList: Attribute StructUnionGroupList; + // 697 - StructUnionGroupList: Attribute StructUnionGroupList; Production { - lhs: 591, - production: &[ParseType::N(591), ParseType::N(45)], + lhs: 604, + production: &[ParseType::N(604), ParseType::N(45)], }, - // 693 - StructUnionGroupList: ; + // 698 - StructUnionGroupList: ; Production { - lhs: 591, + lhs: 604, production: &[], }, - // 694 - StructUnionItem: Identifier Colon ScalarType; + // 699 - StructUnionItem: Identifier Colon ScalarType; Production { - lhs: 592, - production: &[ParseType::N(551), ParseType::N(92), ParseType::N(250)], + lhs: 605, + production: &[ParseType::N(563), ParseType::N(92), ParseType::N(254)], }, - // 695 - InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; + // 700 - InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; Production { - lhs: 288, + lhs: 292, production: &[ - ParseType::N(509), - ParseType::N(289), - ParseType::N(355), - ParseType::N(287), + ParseType::N(521), + ParseType::N(293), + ParseType::N(359), + ParseType::N(291), ], }, - // 696 - InitialDeclarationList: Statement InitialDeclarationList; + // 701 - InitialDeclarationList: Statement InitialDeclarationList; Production { - lhs: 289, - production: &[ParseType::N(289), ParseType::N(573)], + lhs: 293, + production: &[ParseType::N(293), ParseType::N(586)], }, - // 697 - InitialDeclarationList: ; + // 702 - InitialDeclarationList: ; Production { - lhs: 289, + lhs: 293, production: &[], }, - // 698 - FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; + // 703 - FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; Production { - lhs: 212, + lhs: 215, production: &[ - ParseType::N(509), - ParseType::N(213), - ParseType::N(355), - ParseType::N(211), + ParseType::N(521), + ParseType::N(216), + ParseType::N(359), + ParseType::N(214), ], }, - // 699 - FinalDeclarationList: Statement FinalDeclarationList; + // 704 - FinalDeclarationList: Statement FinalDeclarationList; Production { - lhs: 213, - production: &[ParseType::N(213), ParseType::N(573)], + lhs: 216, + production: &[ParseType::N(216), ParseType::N(586)], }, - // 700 - FinalDeclarationList: ; + // 705 - FinalDeclarationList: ; Production { - lhs: 213, + lhs: 216, production: &[], }, - // 701 - InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; + // 706 - InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; Production { - lhs: 303, + lhs: 307, production: &[ - ParseType::N(562), - ParseType::N(306), - ParseType::N(305), - ParseType::N(304), - ParseType::N(554), + ParseType::N(575), + ParseType::N(310), + ParseType::N(309), + ParseType::N(308), + ParseType::N(567), ParseType::N(92), - ParseType::N(250), - ParseType::N(302), + ParseType::N(254), + ParseType::N(306), ], }, - // 702 - InstDeclarationOpt1: LParen InstDeclarationOpt2 /* Option */ RParen; + // 707 - InstDeclarationOpt1: LParen InstDeclarationOpt2 /* Option */ RParen; Production { - lhs: 306, - production: &[ParseType::N(515), ParseType::N(307), ParseType::N(361)], + lhs: 310, + production: &[ParseType::N(527), ParseType::N(311), ParseType::N(365)], }, - // 703 - InstDeclarationOpt2: InstPortList; + // 708 - InstDeclarationOpt2: InstPortList; Production { - lhs: 307, - production: &[ParseType::N(323)], + lhs: 311, + production: &[ParseType::N(327)], }, - // 704 - InstDeclarationOpt2: ; + // 709 - InstDeclarationOpt2: ; Production { - lhs: 307, + lhs: 311, production: &[], }, - // 705 - InstDeclarationOpt1: ; + // 710 - InstDeclarationOpt1: ; Production { - lhs: 306, + lhs: 310, production: &[], }, - // 706 - InstDeclarationOpt0: InstParameter; + // 711 - InstDeclarationOpt0: InstParameter; Production { - lhs: 305, - production: &[ParseType::N(308)], + lhs: 309, + production: &[ParseType::N(312)], }, - // 707 - InstDeclarationOpt0: ; + // 712 - InstDeclarationOpt0: ; Production { - lhs: 305, + lhs: 309, production: &[], }, - // 708 - InstDeclarationOpt: Array; + // 713 - InstDeclarationOpt: Array; Production { - lhs: 304, + lhs: 308, production: &[ParseType::N(23)], }, - // 709 - InstDeclarationOpt: ; + // 714 - InstDeclarationOpt: ; Production { - lhs: 304, + lhs: 308, production: &[], }, - // 710 - InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; + // 715 - InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; Production { - lhs: 308, + lhs: 312, production: &[ - ParseType::N(515), - ParseType::N(317), - ParseType::N(361), - ParseType::N(237), + ParseType::N(527), + ParseType::N(321), + ParseType::N(365), + ParseType::N(241), ], }, - // 711 - InstParameterOpt: InstParameterList; + // 716 - InstParameterOpt: InstParameterList; Production { - lhs: 317, - production: &[ParseType::N(314)], + lhs: 321, + production: &[ParseType::N(318)], }, - // 712 - InstParameterOpt: ; + // 717 - InstParameterOpt: ; Production { - lhs: 317, + lhs: 321, production: &[], }, - // 713 - InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; + // 718 - InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; Production { - lhs: 314, - production: &[ParseType::N(316), ParseType::N(315), ParseType::N(309)], + lhs: 318, + production: &[ParseType::N(320), ParseType::N(319), ParseType::N(313)], }, - // 714 - InstParameterListList: Comma InstParameterGroup InstParameterListList; + // 719 - InstParameterListList: Comma InstParameterGroup InstParameterListList; Production { - lhs: 315, - production: &[ParseType::N(315), ParseType::N(309), ParseType::N(101)], + lhs: 319, + production: &[ParseType::N(319), ParseType::N(313), ParseType::N(101)], }, - // 715 - InstParameterListList: ; + // 720 - InstParameterListList: ; Production { - lhs: 315, + lhs: 319, production: &[], }, - // 716 - InstParameterListOpt: Comma; + // 721 - InstParameterListOpt: Comma; Production { - lhs: 316, + lhs: 320, production: &[ParseType::N(101)], }, - // 717 - InstParameterListOpt: ; + // 722 - InstParameterListOpt: ; Production { - lhs: 316, + lhs: 320, production: &[], }, - // 718 - InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; + // 723 - InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; Production { - lhs: 309, - production: &[ParseType::N(310), ParseType::N(311)], + lhs: 313, + production: &[ParseType::N(314), ParseType::N(315)], }, - // 719 - InstParameterGroupGroup: LBrace InstParameterList RBrace; + // 724 - InstParameterGroupGroup: LBrace InstParameterList RBrace; Production { - lhs: 310, - production: &[ParseType::N(509), ParseType::N(314), ParseType::N(355)], + lhs: 314, + production: &[ParseType::N(521), ParseType::N(318), ParseType::N(359)], }, - // 720 - InstParameterGroupGroup: InstParameterItem; + // 725 - InstParameterGroupGroup: InstParameterItem; Production { - lhs: 310, - production: &[ParseType::N(312)], + lhs: 314, + production: &[ParseType::N(316)], }, - // 721 - InstParameterGroupList: Attribute InstParameterGroupList; + // 726 - InstParameterGroupList: Attribute InstParameterGroupList; Production { - lhs: 311, - production: &[ParseType::N(311), ParseType::N(45)], + lhs: 315, + production: &[ParseType::N(315), ParseType::N(45)], }, - // 722 - InstParameterGroupList: ; + // 727 - InstParameterGroupList: ; Production { - lhs: 311, + lhs: 315, production: &[], }, - // 723 - InstParameterItem: Identifier InstParameterItemOpt /* Option */; + // 728 - InstParameterItem: Identifier InstParameterItemOpt /* Option */; Production { - lhs: 312, - production: &[ParseType::N(313), ParseType::N(250)], + lhs: 316, + production: &[ParseType::N(317), ParseType::N(254)], }, - // 724 - InstParameterItemOpt: Colon Expression; + // 729 - InstParameterItemOpt: Colon Expression; Production { - lhs: 313, - production: &[ParseType::N(170), ParseType::N(92)], + lhs: 317, + production: &[ParseType::N(173), ParseType::N(92)], }, - // 725 - InstParameterItemOpt: ; + // 730 - InstParameterItemOpt: ; Production { - lhs: 313, + lhs: 317, production: &[], }, - // 726 - InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; + // 731 - InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; Production { - lhs: 323, - production: &[ParseType::N(325), ParseType::N(324), ParseType::N(318)], + lhs: 327, + production: &[ParseType::N(329), ParseType::N(328), ParseType::N(322)], }, - // 727 - InstPortListList: Comma InstPortGroup InstPortListList; + // 732 - InstPortListList: Comma InstPortGroup InstPortListList; Production { - lhs: 324, - production: &[ParseType::N(324), ParseType::N(318), ParseType::N(101)], + lhs: 328, + production: &[ParseType::N(328), ParseType::N(322), ParseType::N(101)], }, - // 728 - InstPortListList: ; + // 733 - InstPortListList: ; Production { - lhs: 324, + lhs: 328, production: &[], }, - // 729 - InstPortListOpt: Comma; + // 734 - InstPortListOpt: Comma; Production { - lhs: 325, + lhs: 329, production: &[ParseType::N(101)], }, - // 730 - InstPortListOpt: ; + // 735 - InstPortListOpt: ; Production { - lhs: 325, + lhs: 329, production: &[], }, - // 731 - InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; + // 736 - InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; Production { - lhs: 318, - production: &[ParseType::N(319), ParseType::N(320)], + lhs: 322, + production: &[ParseType::N(323), ParseType::N(324)], }, - // 732 - InstPortGroupGroup: LBrace InstPortList RBrace; + // 737 - InstPortGroupGroup: LBrace InstPortList RBrace; Production { - lhs: 319, - production: &[ParseType::N(509), ParseType::N(323), ParseType::N(355)], + lhs: 323, + production: &[ParseType::N(521), ParseType::N(327), ParseType::N(359)], }, - // 733 - InstPortGroupGroup: InstPortItem; + // 738 - InstPortGroupGroup: InstPortItem; Production { - lhs: 319, - production: &[ParseType::N(321)], + lhs: 323, + production: &[ParseType::N(325)], }, - // 734 - InstPortGroupList: Attribute InstPortGroupList; + // 739 - InstPortGroupList: Attribute InstPortGroupList; Production { - lhs: 320, - production: &[ParseType::N(320), ParseType::N(45)], + lhs: 324, + production: &[ParseType::N(324), ParseType::N(45)], }, - // 735 - InstPortGroupList: ; + // 740 - InstPortGroupList: ; Production { - lhs: 320, + lhs: 324, production: &[], }, - // 736 - InstPortItem: Identifier InstPortItemOpt /* Option */; + // 741 - InstPortItem: Identifier InstPortItemOpt /* Option */; Production { - lhs: 321, - production: &[ParseType::N(322), ParseType::N(250)], + lhs: 325, + production: &[ParseType::N(326), ParseType::N(254)], }, - // 737 - InstPortItemOpt: Colon Expression; + // 742 - InstPortItemOpt: Colon Expression; Production { - lhs: 322, - production: &[ParseType::N(170), ParseType::N(92)], + lhs: 326, + production: &[ParseType::N(173), ParseType::N(92)], }, - // 738 - InstPortItemOpt: ; + // 743 - InstPortItemOpt: ; Production { - lhs: 322, + lhs: 326, production: &[], }, - // 739 - WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; + // 744 - WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; Production { - lhs: 660, + lhs: 671, production: &[ - ParseType::N(515), - ParseType::N(670), - ParseType::N(361), - ParseType::N(237), + ParseType::N(527), + ParseType::N(681), + ParseType::N(365), + ParseType::N(241), ], }, - // 740 - WithParameterOpt: WithParameterList; + // 745 - WithParameterOpt: WithParameterList; Production { - lhs: 670, - production: &[ParseType::N(667)], + lhs: 681, + production: &[ParseType::N(678)], }, - // 741 - WithParameterOpt: ; + // 746 - WithParameterOpt: ; Production { - lhs: 670, + lhs: 681, production: &[], }, - // 742 - WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; + // 747 - WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; Production { - lhs: 667, - production: &[ParseType::N(669), ParseType::N(668), ParseType::N(661)], + lhs: 678, + production: &[ParseType::N(680), ParseType::N(679), ParseType::N(672)], }, - // 743 - WithParameterListList: Comma WithParameterGroup WithParameterListList; + // 748 - WithParameterListList: Comma WithParameterGroup WithParameterListList; Production { - lhs: 668, - production: &[ParseType::N(668), ParseType::N(661), ParseType::N(101)], + lhs: 679, + production: &[ParseType::N(679), ParseType::N(672), ParseType::N(101)], }, - // 744 - WithParameterListList: ; + // 749 - WithParameterListList: ; Production { - lhs: 668, + lhs: 679, production: &[], }, - // 745 - WithParameterListOpt: Comma; + // 750 - WithParameterListOpt: Comma; Production { - lhs: 669, + lhs: 680, production: &[ParseType::N(101)], }, - // 746 - WithParameterListOpt: ; + // 751 - WithParameterListOpt: ; Production { - lhs: 669, + lhs: 680, production: &[], }, - // 747 - WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; + // 752 - WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; Production { - lhs: 661, - production: &[ParseType::N(662), ParseType::N(663)], + lhs: 672, + production: &[ParseType::N(673), ParseType::N(674)], }, - // 748 - WithParameterGroupGroup: LBrace WithParameterList RBrace; + // 753 - WithParameterGroupGroup: LBrace WithParameterList RBrace; Production { - lhs: 662, - production: &[ParseType::N(509), ParseType::N(667), ParseType::N(355)], + lhs: 673, + production: &[ParseType::N(521), ParseType::N(678), ParseType::N(359)], }, - // 749 - WithParameterGroupGroup: WithParameterItem; + // 754 - WithParameterGroupGroup: WithParameterItem; Production { - lhs: 662, - production: &[ParseType::N(664)], + lhs: 673, + production: &[ParseType::N(675)], }, - // 750 - WithParameterGroupList: Attribute WithParameterGroupList; + // 755 - WithParameterGroupList: Attribute WithParameterGroupList; Production { - lhs: 663, - production: &[ParseType::N(663), ParseType::N(45)], + lhs: 674, + production: &[ParseType::N(674), ParseType::N(45)], }, - // 751 - WithParameterGroupList: ; + // 756 - WithParameterGroupList: ; Production { - lhs: 663, + lhs: 674, production: &[], }, - // 752 - WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; + // 757 - WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; Production { - lhs: 664, + lhs: 675, production: &[ - ParseType::N(666), + ParseType::N(677), ParseType::N(92), - ParseType::N(250), - ParseType::N(665), + ParseType::N(254), + ParseType::N(676), ], }, - // 753 - WithParameterItemGroup0: ArrayType Equ Expression; + // 758 - WithParameterItemGroup0: ArrayType Equ Expression; Production { - lhs: 666, - production: &[ParseType::N(170), ParseType::N(158), ParseType::N(31)], + lhs: 677, + production: &[ParseType::N(173), ParseType::N(161), ParseType::N(31)], }, - // 754 - WithParameterItemGroup0: Type Equ TypeExpression; + // 759 - WithParameterItemGroup0: Type Equ TypeExpression; Production { - lhs: 666, - production: &[ParseType::N(615), ParseType::N(158), ParseType::N(613)], + lhs: 677, + production: &[ParseType::N(628), ParseType::N(161), ParseType::N(626)], }, - // 755 - WithParameterItemGroup: Param; + // 760 - WithParameterItemGroup: Param; Production { - lhs: 665, - production: &[ParseType::N(479)], + lhs: 676, + production: &[ParseType::N(484)], }, - // 756 - WithParameterItemGroup: Local; + // 761 - WithParameterItemGroup: Local; Production { - lhs: 665, - production: &[ParseType::N(371)], + lhs: 676, + production: &[ParseType::N(375)], }, - // 757 - WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; + // 762 - GenericBound: Const; Production { - lhs: 654, - production: &[ParseType::N(506), ParseType::N(657), ParseType::N(94)], + lhs: 240, + production: &[ParseType::N(112)], }, - // 758 - WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */; + // 763 - GenericBound: Type; Production { - lhs: 657, - production: &[ParseType::N(659), ParseType::N(658), ParseType::N(655)], + lhs: 240, + production: &[ParseType::N(626)], }, - // 759 - WithGenericParameterListList: Comma WithGenericParameterItem WithGenericParameterListList; + // 764 - GenericBound: ScopedIdentifier; Production { - lhs: 658, - production: &[ParseType::N(658), ParseType::N(655), ParseType::N(101)], + lhs: 240, + production: &[ParseType::N(567)], }, - // 760 - WithGenericParameterListList: ; + // 765 - WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; Production { - lhs: 658, + lhs: 665, + production: &[ParseType::N(518), ParseType::N(668), ParseType::N(94)], + }, + // 766 - WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */; + Production { + lhs: 668, + production: &[ParseType::N(670), ParseType::N(669), ParseType::N(666)], + }, + // 767 - WithGenericParameterListList: Comma WithGenericParameterItem WithGenericParameterListList; + Production { + lhs: 669, + production: &[ParseType::N(669), ParseType::N(666), ParseType::N(101)], + }, + // 768 - WithGenericParameterListList: ; + Production { + lhs: 669, production: &[], }, - // 761 - WithGenericParameterListOpt: Comma; + // 769 - WithGenericParameterListOpt: Comma; Production { - lhs: 659, + lhs: 670, production: &[ParseType::N(101)], }, - // 762 - WithGenericParameterListOpt: ; + // 770 - WithGenericParameterListOpt: ; Production { - lhs: 659, + lhs: 670, production: &[], }, - // 763 - WithGenericParameterItem: Identifier WithGenericParameterItemOpt /* Option */; + // 771 - WithGenericParameterItem: Identifier Colon GenericBound WithGenericParameterItemOpt /* Option */; Production { - lhs: 655, - production: &[ParseType::N(656), ParseType::N(250)], + lhs: 666, + production: &[ + ParseType::N(667), + ParseType::N(240), + ParseType::N(92), + ParseType::N(254), + ], }, - // 764 - WithGenericParameterItemOpt: Equ WithGenericArgumentItem; + // 772 - WithGenericParameterItemOpt: Equ WithGenericArgumentItem; Production { - lhs: 656, - production: &[ParseType::N(649), ParseType::N(158)], + lhs: 667, + production: &[ParseType::N(660), ParseType::N(161)], }, - // 765 - WithGenericParameterItemOpt: ; + // 773 - WithGenericParameterItemOpt: ; Production { - lhs: 656, + lhs: 667, production: &[], }, - // 766 - WithGenericArgument: ColonColonLAngle Push(2) WithGenericArgumentOpt /* Option */ RAngle Pop; + // 774 - WithGenericArgument: ColonColonLAngle Push(2) WithGenericArgumentOpt /* Option */ RAngle Pop; Production { - lhs: 648, + lhs: 659, production: &[ ParseType::Pop, - ParseType::N(506), - ParseType::N(653), + ParseType::N(518), + ParseType::N(664), ParseType::Push(2), ParseType::N(94), ], }, - // 767 - WithGenericArgumentOpt: WithGenericArgumentList; + // 775 - WithGenericArgumentOpt: WithGenericArgumentList; Production { - lhs: 653, - production: &[ParseType::N(650)], + lhs: 664, + production: &[ParseType::N(661)], }, - // 768 - WithGenericArgumentOpt: ; + // 776 - WithGenericArgumentOpt: ; Production { - lhs: 653, + lhs: 664, production: &[], }, - // 769 - WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */; + // 777 - WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */; Production { - lhs: 650, - production: &[ParseType::N(652), ParseType::N(651), ParseType::N(649)], + lhs: 661, + production: &[ParseType::N(663), ParseType::N(662), ParseType::N(660)], }, - // 770 - WithGenericArgumentListList: Comma WithGenericArgumentItem WithGenericArgumentListList; + // 778 - WithGenericArgumentListList: Comma WithGenericArgumentItem WithGenericArgumentListList; Production { - lhs: 651, - production: &[ParseType::N(651), ParseType::N(649), ParseType::N(101)], + lhs: 662, + production: &[ParseType::N(662), ParseType::N(660), ParseType::N(101)], }, - // 771 - WithGenericArgumentListList: ; + // 779 - WithGenericArgumentListList: ; Production { - lhs: 651, + lhs: 662, production: &[], }, - // 772 - WithGenericArgumentListOpt: Comma; + // 780 - WithGenericArgumentListOpt: Comma; Production { - lhs: 652, + lhs: 663, production: &[ParseType::N(101)], }, - // 773 - WithGenericArgumentListOpt: ; + // 781 - WithGenericArgumentListOpt: ; Production { - lhs: 652, + lhs: 663, production: &[], }, - // 774 - WithGenericArgumentItem: ScopedIdentifier; + // 782 - WithGenericArgumentItem: ScopedIdentifier; Production { - lhs: 649, - production: &[ParseType::N(554)], + lhs: 660, + production: &[ParseType::N(567)], }, - // 775 - WithGenericArgumentItem: Number; + // 783 - WithGenericArgumentItem: Number; Production { - lhs: 649, - production: &[ParseType::N(426)], + lhs: 660, + production: &[ParseType::N(431)], }, - // 776 - PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; + // 784 - PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; Production { - lhs: 485, - production: &[ParseType::N(515), ParseType::N(494), ParseType::N(361)], + lhs: 490, + production: &[ParseType::N(527), ParseType::N(499), ParseType::N(365)], }, - // 777 - PortDeclarationOpt: PortDeclarationList; + // 785 - PortDeclarationOpt: PortDeclarationList; Production { - lhs: 494, - production: &[ParseType::N(491)], + lhs: 499, + production: &[ParseType::N(496)], }, - // 778 - PortDeclarationOpt: ; + // 786 - PortDeclarationOpt: ; Production { - lhs: 494, + lhs: 499, production: &[], }, - // 779 - PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; + // 787 - PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; Production { - lhs: 491, - production: &[ParseType::N(493), ParseType::N(492), ParseType::N(486)], + lhs: 496, + production: &[ParseType::N(498), ParseType::N(497), ParseType::N(491)], }, - // 780 - PortDeclarationListList: Comma PortDeclarationGroup PortDeclarationListList; + // 788 - PortDeclarationListList: Comma PortDeclarationGroup PortDeclarationListList; Production { - lhs: 492, - production: &[ParseType::N(492), ParseType::N(486), ParseType::N(101)], + lhs: 497, + production: &[ParseType::N(497), ParseType::N(491), ParseType::N(101)], }, - // 781 - PortDeclarationListList: ; + // 789 - PortDeclarationListList: ; Production { - lhs: 492, + lhs: 497, production: &[], }, - // 782 - PortDeclarationListOpt: Comma; + // 790 - PortDeclarationListOpt: Comma; Production { - lhs: 493, + lhs: 498, production: &[ParseType::N(101)], }, - // 783 - PortDeclarationListOpt: ; + // 791 - PortDeclarationListOpt: ; Production { - lhs: 493, + lhs: 498, production: &[], }, - // 784 - PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; + // 792 - PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; Production { - lhs: 486, - production: &[ParseType::N(487), ParseType::N(488)], + lhs: 491, + production: &[ParseType::N(492), ParseType::N(493)], }, - // 785 - PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; + // 793 - PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; Production { - lhs: 487, - production: &[ParseType::N(509), ParseType::N(491), ParseType::N(355)], + lhs: 492, + production: &[ParseType::N(521), ParseType::N(496), ParseType::N(359)], }, - // 786 - PortDeclarationGroupGroup: PortDeclarationItem; + // 794 - PortDeclarationGroupGroup: PortDeclarationItem; Production { - lhs: 487, - production: &[ParseType::N(489)], + lhs: 492, + production: &[ParseType::N(494)], }, - // 787 - PortDeclarationGroupList: Attribute PortDeclarationGroupList; + // 795 - PortDeclarationGroupList: Attribute PortDeclarationGroupList; Production { - lhs: 488, - production: &[ParseType::N(488), ParseType::N(45)], + lhs: 493, + production: &[ParseType::N(493), ParseType::N(45)], }, - // 788 - PortDeclarationGroupList: ; + // 796 - PortDeclarationGroupList: ; Production { - lhs: 488, + lhs: 493, production: &[], }, - // 789 - PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; + // 797 - PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; Production { - lhs: 489, - production: &[ParseType::N(490), ParseType::N(92), ParseType::N(250)], + lhs: 494, + production: &[ParseType::N(495), ParseType::N(92), ParseType::N(254)], }, - // 790 - PortDeclarationItemGroup: PortTypeConcrete; + // 798 - PortDeclarationItemGroup: PortTypeConcrete; Production { - lhs: 490, - production: &[ParseType::N(498)], + lhs: 495, + production: &[ParseType::N(503)], }, - // 791 - PortDeclarationItemGroup: PortTypeAbstract; + // 799 - PortDeclarationItemGroup: PortTypeAbstract; Production { - lhs: 490, - production: &[ParseType::N(495)], + lhs: 495, + production: &[ParseType::N(500)], }, - // 792 - PortTypeConcrete: Direction PortTypeConcreteOpt /* Option */ ArrayType; + // 800 - PortTypeConcrete: Direction PortTypeConcreteOpt /* Option */ ArrayType; Production { - lhs: 498, - production: &[ParseType::N(31), ParseType::N(499), ParseType::N(120)], + lhs: 503, + production: &[ParseType::N(31), ParseType::N(504), ParseType::N(123)], }, - // 793 - PortTypeConcreteOpt: ClockDomain; + // 801 - PortTypeConcreteOpt: ClockDomain; Production { - lhs: 499, + lhs: 504, production: &[ParseType::N(83)], }, - // 794 - PortTypeConcreteOpt: ; + // 802 - PortTypeConcreteOpt: ; Production { - lhs: 499, + lhs: 504, production: &[], }, - // 795 - PortTypeAbstract: PortTypeAbstractOpt /* Option */ Interface PortTypeAbstractOpt0 /* Option */; + // 803 - PortTypeAbstract: PortTypeAbstractOpt /* Option */ Interface PortTypeAbstractOpt0 /* Option */; Production { - lhs: 495, - production: &[ParseType::N(497), ParseType::N(329), ParseType::N(496)], + lhs: 500, + production: &[ParseType::N(502), ParseType::N(333), ParseType::N(501)], }, - // 796 - PortTypeAbstractOpt0: Array; + // 804 - PortTypeAbstractOpt0: Array; Production { - lhs: 497, + lhs: 502, production: &[ParseType::N(23)], }, - // 797 - PortTypeAbstractOpt0: ; + // 805 - PortTypeAbstractOpt0: ; Production { - lhs: 497, + lhs: 502, production: &[], }, - // 798 - PortTypeAbstractOpt: ClockDomain; + // 806 - PortTypeAbstractOpt: ClockDomain; Production { - lhs: 496, + lhs: 501, production: &[ParseType::N(83)], }, - // 799 - PortTypeAbstractOpt: ; + // 807 - PortTypeAbstractOpt: ; Production { - lhs: 496, + lhs: 501, production: &[], }, - // 800 - Direction: Input; + // 808 - Direction: Input; Production { - lhs: 120, - production: &[ParseType::N(295)], + lhs: 123, + production: &[ParseType::N(299)], }, - // 801 - Direction: Output; + // 809 - Direction: Output; Production { - lhs: 120, - production: &[ParseType::N(460)], + lhs: 123, + production: &[ParseType::N(465)], }, - // 802 - Direction: Inout; + // 810 - Direction: Inout; Production { - lhs: 120, - production: &[ParseType::N(292)], + lhs: 123, + production: &[ParseType::N(296)], }, - // 803 - Direction: Ref; + // 811 - Direction: Ref; Production { - lhs: 120, - production: &[ParseType::N(526)], + lhs: 123, + production: &[ParseType::N(538)], }, - // 804 - Direction: Modport; + // 812 - Direction: Modport; Production { - lhs: 120, - production: &[ParseType::N(388)], + lhs: 123, + production: &[ParseType::N(392)], }, - // 805 - Direction: Import; + // 813 - Direction: Import; Production { - lhs: 120, - production: &[ParseType::N(275)], + lhs: 123, + production: &[ParseType::N(279)], }, - // 806 - FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; + // 814 - FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; Production { - lhs: 229, + lhs: 232, production: &[ - ParseType::N(509), - ParseType::N(230), - ParseType::N(355), + ParseType::N(521), ParseType::N(233), - ParseType::N(232), - ParseType::N(231), - ParseType::N(250), - ParseType::N(226), + ParseType::N(359), + ParseType::N(236), + ParseType::N(235), + ParseType::N(234), + ParseType::N(254), + ParseType::N(229), ], }, - // 807 - FunctionDeclarationList: FunctionItem FunctionDeclarationList; + // 815 - FunctionDeclarationList: FunctionItem FunctionDeclarationList; Production { - lhs: 230, - production: &[ParseType::N(230), ParseType::N(234)], + lhs: 233, + production: &[ParseType::N(233), ParseType::N(237)], }, - // 808 - FunctionDeclarationList: ; + // 816 - FunctionDeclarationList: ; Production { - lhs: 230, + lhs: 233, production: &[], }, - // 809 - FunctionDeclarationOpt1: MinusGT ScalarType; + // 817 - FunctionDeclarationOpt1: MinusGT ScalarType; Production { - lhs: 233, - production: &[ParseType::N(551), ParseType::N(385)], + lhs: 236, + production: &[ParseType::N(563), ParseType::N(389)], }, - // 810 - FunctionDeclarationOpt1: ; + // 818 - FunctionDeclarationOpt1: ; Production { - lhs: 233, + lhs: 236, production: &[], }, - // 811 - FunctionDeclarationOpt0: PortDeclaration; + // 819 - FunctionDeclarationOpt0: PortDeclaration; Production { - lhs: 232, - production: &[ParseType::N(485)], + lhs: 235, + production: &[ParseType::N(490)], }, - // 812 - FunctionDeclarationOpt0: ; + // 820 - FunctionDeclarationOpt0: ; Production { - lhs: 232, + lhs: 235, production: &[], }, - // 813 - FunctionDeclarationOpt: WithGenericParameter; + // 821 - FunctionDeclarationOpt: WithGenericParameter; Production { - lhs: 231, - production: &[ParseType::N(654)], + lhs: 234, + production: &[ParseType::N(665)], }, - // 814 - FunctionDeclarationOpt: ; + // 822 - FunctionDeclarationOpt: ; Production { - lhs: 231, + lhs: 234, production: &[], }, - // 815 - FunctionItem: VarDeclaration; + // 823 - FunctionItem: VarDeclaration; Production { - lhs: 234, - production: &[ParseType::N(637)], + lhs: 237, + production: &[ParseType::N(650)], }, - // 816 - FunctionItem: Statement; + // 824 - FunctionItem: Statement; Production { - lhs: 234, - production: &[ParseType::N(573)], + lhs: 237, + production: &[ParseType::N(586)], }, - // 817 - ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; + // 825 - ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; Production { - lhs: 276, + lhs: 280, production: &[ - ParseType::N(562), - ParseType::N(277), - ParseType::N(554), - ParseType::N(275), + ParseType::N(575), + ParseType::N(281), + ParseType::N(567), + ParseType::N(279), ], }, - // 818 - ImportDeclarationOpt: ColonColon Star; + // 826 - ImportDeclarationOpt: ColonColon Star; Production { - lhs: 277, - production: &[ParseType::N(568), ParseType::N(93)], + lhs: 281, + production: &[ParseType::N(581), ParseType::N(93)], }, - // 819 - ImportDeclarationOpt: ; + // 827 - ImportDeclarationOpt: ; Production { - lhs: 277, + lhs: 281, production: &[], }, - // 820 - ExportDeclaration: Export ExportDeclarationGroup Semicolon; + // 828 - ExportDeclaration: Export ExportDeclarationGroup Semicolon; Production { - lhs: 165, - production: &[ParseType::N(562), ParseType::N(166), ParseType::N(164)], + lhs: 168, + production: &[ParseType::N(575), ParseType::N(169), ParseType::N(167)], }, - // 821 - ExportDeclarationGroup: Star; + // 829 - ExportDeclarationGroup: Star; Production { - lhs: 166, - production: &[ParseType::N(568)], + lhs: 169, + production: &[ParseType::N(581)], }, - // 822 - ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; + // 830 - ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; Production { - lhs: 166, - production: &[ParseType::N(167), ParseType::N(554)], + lhs: 169, + production: &[ParseType::N(170), ParseType::N(567)], }, - // 823 - ExportDeclarationOpt: ColonColon Star; + // 831 - ExportDeclarationOpt: ColonColon Star; Production { - lhs: 167, - production: &[ParseType::N(568), ParseType::N(93)], + lhs: 170, + production: &[ParseType::N(581), ParseType::N(93)], }, - // 824 - ExportDeclarationOpt: ; + // 832 - ExportDeclarationOpt: ; Production { - lhs: 167, + lhs: 170, production: &[], }, - // 825 - UnsafeBlock: Unsafe LParen Identifier RParen LBrace UnsafeBlockList /* Vec */ RBrace; + // 833 - UnsafeBlock: Unsafe LParen Identifier RParen LBrace UnsafeBlockList /* Vec */ RBrace; Production { - lhs: 632, + lhs: 645, production: &[ - ParseType::N(509), - ParseType::N(633), - ParseType::N(355), - ParseType::N(515), - ParseType::N(250), - ParseType::N(361), - ParseType::N(631), + ParseType::N(521), + ParseType::N(646), + ParseType::N(359), + ParseType::N(527), + ParseType::N(254), + ParseType::N(365), + ParseType::N(644), ], }, - // 826 - UnsafeBlockList: ModuleGroup UnsafeBlockList; + // 834 - UnsafeBlockList: ModuleGroup UnsafeBlockList; Production { - lhs: 633, - production: &[ParseType::N(633), ParseType::N(408)], + lhs: 646, + production: &[ParseType::N(646), ParseType::N(413)], }, - // 827 - UnsafeBlockList: ; + // 835 - UnsafeBlockList: ; Production { - lhs: 633, + lhs: 646, production: &[], }, - // 828 - ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; + // 836 - ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ ModuleDeclarationOpt3 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; Production { - lhs: 400, + lhs: 404, production: &[ - ParseType::N(509), - ParseType::N(401), - ParseType::N(355), + ParseType::N(521), ParseType::N(405), - ParseType::N(404), + ParseType::N(359), + ParseType::N(410), + ParseType::N(409), + ParseType::N(408), + ParseType::N(407), + ParseType::N(254), ParseType::N(403), - ParseType::N(250), - ParseType::N(399), - ParseType::N(402), + ParseType::N(406), ], }, - // 829 - ModuleDeclarationList: ModuleGroup ModuleDeclarationList; + // 837 - ModuleDeclarationList: ModuleGroup ModuleDeclarationList; Production { - lhs: 401, - production: &[ParseType::N(401), ParseType::N(408)], + lhs: 405, + production: &[ParseType::N(405), ParseType::N(413)], }, - // 830 - ModuleDeclarationList: ; + // 838 - ModuleDeclarationList: ; Production { - lhs: 401, + lhs: 405, production: &[], }, - // 831 - ModuleDeclarationOpt2: PortDeclaration; + // 839 - ModuleDeclarationOpt3: PortDeclaration; Production { - lhs: 405, - production: &[ParseType::N(485)], + lhs: 410, + production: &[ParseType::N(490)], }, - // 832 - ModuleDeclarationOpt2: ; + // 840 - ModuleDeclarationOpt3: ; Production { - lhs: 405, + lhs: 410, production: &[], }, - // 833 - ModuleDeclarationOpt1: WithParameter; + // 841 - ModuleDeclarationOpt2: WithParameter; Production { - lhs: 404, - production: &[ParseType::N(660)], + lhs: 409, + production: &[ParseType::N(671)], }, - // 834 - ModuleDeclarationOpt1: ; + // 842 - ModuleDeclarationOpt2: ; Production { - lhs: 404, + lhs: 409, production: &[], }, - // 835 - ModuleDeclarationOpt0: WithGenericParameter; + // 843 - ModuleDeclarationOpt1: For ScopedIdentifier; Production { - lhs: 403, - production: &[ParseType::N(654)], + lhs: 408, + production: &[ParseType::N(567), ParseType::N(223)], }, - // 836 - ModuleDeclarationOpt0: ; + // 844 - ModuleDeclarationOpt1: ; Production { - lhs: 403, + lhs: 408, production: &[], }, - // 837 - ModuleDeclarationOpt: Pub; + // 845 - ModuleDeclarationOpt0: WithGenericParameter; Production { - lhs: 402, - production: &[ParseType::N(500)], + lhs: 407, + production: &[ParseType::N(665)], }, - // 838 - ModuleDeclarationOpt: ; + // 846 - ModuleDeclarationOpt0: ; Production { - lhs: 402, + lhs: 407, production: &[], }, - // 839 - ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; + // 847 - ModuleDeclarationOpt: Pub; Production { - lhs: 412, + lhs: 406, + production: &[ParseType::N(512)], + }, + // 848 - ModuleDeclarationOpt: ; + Production { + lhs: 406, + production: &[], + }, + // 849 - ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; + Production { + lhs: 417, production: &[ - ParseType::N(414), - ParseType::N(413), - ParseType::N(416), - ParseType::N(170), - ParseType::N(255), + ParseType::N(419), + ParseType::N(418), + ParseType::N(421), + ParseType::N(173), + ParseType::N(259), ], }, - // 840 - ModuleIfDeclarationList: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; + // 850 - ModuleIfDeclarationList: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; Production { - lhs: 413, + lhs: 418, production: &[ - ParseType::N(413), ParseType::N(418), - ParseType::N(170), - ParseType::N(255), - ParseType::N(133), + ParseType::N(423), + ParseType::N(173), + ParseType::N(259), + ParseType::N(136), ], }, - // 841 - ModuleIfDeclarationList: ; + // 851 - ModuleIfDeclarationList: ; Production { - lhs: 413, + lhs: 418, production: &[], }, - // 842 - ModuleIfDeclarationOpt: Else ModuleOptionalNamedBlock; + // 852 - ModuleIfDeclarationOpt: Else ModuleOptionalNamedBlock; Production { - lhs: 414, - production: &[ParseType::N(418), ParseType::N(133)], + lhs: 419, + production: &[ParseType::N(423), ParseType::N(136)], }, - // 843 - ModuleIfDeclarationOpt: ; + // 853 - ModuleIfDeclarationOpt: ; Production { - lhs: 414, + lhs: 419, production: &[], }, - // 844 - ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; + // 854 - ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; Production { - lhs: 406, + lhs: 411, production: &[ - ParseType::N(416), - ParseType::N(407), - ParseType::N(518), - ParseType::N(280), - ParseType::N(250), - ParseType::N(220), + ParseType::N(421), + ParseType::N(412), + ParseType::N(530), + ParseType::N(284), + ParseType::N(254), + ParseType::N(223), ], }, - // 845 - ModuleForDeclarationOpt: Step AssignmentOperator Expression; + // 855 - ModuleForDeclarationOpt: Step AssignmentOperator Expression; Production { - lhs: 407, - production: &[ParseType::N(170), ParseType::N(42), ParseType::N(574)], + lhs: 412, + production: &[ParseType::N(173), ParseType::N(42), ParseType::N(587)], }, - // 846 - ModuleForDeclarationOpt: ; + // 856 - ModuleForDeclarationOpt: ; Production { - lhs: 407, + lhs: 412, production: &[], }, - // 847 - ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; + // 857 - ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; Production { - lhs: 416, + lhs: 421, production: &[ - ParseType::N(509), - ParseType::N(417), - ParseType::N(355), - ParseType::N(250), + ParseType::N(521), + ParseType::N(422), + ParseType::N(359), + ParseType::N(254), ParseType::N(92), ], }, - // 848 - ModuleNamedBlockList: ModuleGroup ModuleNamedBlockList; + // 858 - ModuleNamedBlockList: ModuleGroup ModuleNamedBlockList; Production { - lhs: 417, - production: &[ParseType::N(417), ParseType::N(408)], + lhs: 422, + production: &[ParseType::N(422), ParseType::N(413)], }, - // 849 - ModuleNamedBlockList: ; + // 859 - ModuleNamedBlockList: ; Production { - lhs: 417, + lhs: 422, production: &[], }, - // 850 - ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; + // 860 - ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; Production { - lhs: 418, + lhs: 423, production: &[ - ParseType::N(509), - ParseType::N(419), - ParseType::N(355), - ParseType::N(420), + ParseType::N(521), + ParseType::N(424), + ParseType::N(359), + ParseType::N(425), ], }, - // 851 - ModuleOptionalNamedBlockList: ModuleGroup ModuleOptionalNamedBlockList; + // 861 - ModuleOptionalNamedBlockList: ModuleGroup ModuleOptionalNamedBlockList; Production { - lhs: 419, - production: &[ParseType::N(419), ParseType::N(408)], + lhs: 424, + production: &[ParseType::N(424), ParseType::N(413)], }, - // 852 - ModuleOptionalNamedBlockList: ; + // 862 - ModuleOptionalNamedBlockList: ; Production { - lhs: 419, + lhs: 424, production: &[], }, - // 853 - ModuleOptionalNamedBlockOpt: Colon Identifier; + // 863 - ModuleOptionalNamedBlockOpt: Colon Identifier; Production { - lhs: 420, - production: &[ParseType::N(250), ParseType::N(92)], + lhs: 425, + production: &[ParseType::N(254), ParseType::N(92)], }, - // 854 - ModuleOptionalNamedBlockOpt: ; + // 864 - ModuleOptionalNamedBlockOpt: ; Production { - lhs: 420, + lhs: 425, production: &[], }, - // 855 - ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; + // 865 - ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; Production { - lhs: 408, - production: &[ParseType::N(409), ParseType::N(411)], + lhs: 413, + production: &[ParseType::N(414), ParseType::N(416)], }, - // 856 - ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; + // 866 - ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; Production { - lhs: 409, - production: &[ParseType::N(509), ParseType::N(410), ParseType::N(355)], + lhs: 414, + production: &[ParseType::N(521), ParseType::N(415), ParseType::N(359)], }, - // 857 - ModuleGroupGroupList: ModuleGroup ModuleGroupGroupList; + // 867 - ModuleGroupGroupList: ModuleGroup ModuleGroupGroupList; Production { - lhs: 410, - production: &[ParseType::N(410), ParseType::N(408)], + lhs: 415, + production: &[ParseType::N(415), ParseType::N(413)], }, - // 858 - ModuleGroupGroupList: ; + // 868 - ModuleGroupGroupList: ; Production { - lhs: 410, + lhs: 415, production: &[], }, - // 859 - ModuleGroupGroup: ModuleItem; + // 869 - ModuleGroupGroup: ModuleItem; Production { - lhs: 409, - production: &[ParseType::N(415)], + lhs: 414, + production: &[ParseType::N(420)], }, - // 860 - ModuleGroupList: Attribute ModuleGroupList; + // 870 - ModuleGroupList: Attribute ModuleGroupList; Production { - lhs: 411, - production: &[ParseType::N(411), ParseType::N(45)], + lhs: 416, + production: &[ParseType::N(416), ParseType::N(45)], }, - // 861 - ModuleGroupList: ; + // 871 - ModuleGroupList: ; Production { - lhs: 411, + lhs: 416, production: &[], }, - // 862 - ModuleItem: LetDeclaration; + // 872 - ModuleItem: LetDeclaration; Production { - lhs: 415, - production: &[ParseType::N(365)], + lhs: 420, + production: &[ParseType::N(369)], }, - // 863 - ModuleItem: VarDeclaration; + // 873 - ModuleItem: VarDeclaration; Production { - lhs: 415, - production: &[ParseType::N(637)], + lhs: 420, + production: &[ParseType::N(650)], }, - // 864 - ModuleItem: InstDeclaration; + // 874 - ModuleItem: InstDeclaration; Production { - lhs: 415, - production: &[ParseType::N(303)], + lhs: 420, + production: &[ParseType::N(307)], }, - // 865 - ModuleItem: TypeDefDeclaration; + // 875 - ModuleItem: TypeDefDeclaration; Production { - lhs: 415, - production: &[ParseType::N(614)], + lhs: 420, + production: &[ParseType::N(627)], }, - // 866 - ModuleItem: LocalDeclaration; + // 876 - ModuleItem: LocalDeclaration; Production { - lhs: 415, - production: &[ParseType::N(372)], + lhs: 420, + production: &[ParseType::N(376)], }, - // 867 - ModuleItem: AlwaysFfDeclaration; + // 877 - ModuleItem: AlwaysFfDeclaration; Production { - lhs: 415, + lhs: 420, production: &[ParseType::N(12)], }, - // 868 - ModuleItem: AlwaysCombDeclaration; + // 878 - ModuleItem: AlwaysCombDeclaration; Production { - lhs: 415, + lhs: 420, production: &[ParseType::N(6)], }, - // 869 - ModuleItem: AssignDeclaration; + // 879 - ModuleItem: AssignDeclaration; Production { - lhs: 415, + lhs: 420, production: &[ParseType::N(37)], }, - // 870 - ModuleItem: FunctionDeclaration; + // 880 - ModuleItem: FunctionDeclaration; Production { - lhs: 415, - production: &[ParseType::N(229)], + lhs: 420, + production: &[ParseType::N(232)], }, - // 871 - ModuleItem: ModuleIfDeclaration; + // 881 - ModuleItem: ModuleIfDeclaration; Production { - lhs: 415, - production: &[ParseType::N(412)], + lhs: 420, + production: &[ParseType::N(417)], }, - // 872 - ModuleItem: ModuleForDeclaration; + // 882 - ModuleItem: ModuleForDeclaration; Production { - lhs: 415, - production: &[ParseType::N(406)], + lhs: 420, + production: &[ParseType::N(411)], }, - // 873 - ModuleItem: EnumDeclaration; + // 883 - ModuleItem: EnumDeclaration; Production { - lhs: 415, - production: &[ParseType::N(146)], + lhs: 420, + production: &[ParseType::N(149)], }, - // 874 - ModuleItem: StructUnionDeclaration; + // 884 - ModuleItem: StructUnionDeclaration; Production { - lhs: 415, - production: &[ParseType::N(587)], + lhs: 420, + production: &[ParseType::N(600)], }, - // 875 - ModuleItem: ModuleNamedBlock; + // 885 - ModuleItem: ModuleNamedBlock; Production { - lhs: 415, - production: &[ParseType::N(416)], + lhs: 420, + production: &[ParseType::N(421)], }, - // 876 - ModuleItem: ImportDeclaration; + // 886 - ModuleItem: ImportDeclaration; Production { - lhs: 415, - production: &[ParseType::N(276)], + lhs: 420, + production: &[ParseType::N(280)], }, - // 877 - ModuleItem: InitialDeclaration; + // 887 - ModuleItem: InitialDeclaration; Production { - lhs: 415, - production: &[ParseType::N(288)], + lhs: 420, + production: &[ParseType::N(292)], }, - // 878 - ModuleItem: FinalDeclaration; + // 888 - ModuleItem: FinalDeclaration; Production { - lhs: 415, - production: &[ParseType::N(212)], + lhs: 420, + production: &[ParseType::N(215)], }, - // 879 - ModuleItem: UnsafeBlock; + // 889 - ModuleItem: UnsafeBlock; Production { - lhs: 415, - production: &[ParseType::N(632)], + lhs: 420, + production: &[ParseType::N(645)], }, - // 880 - InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; + // 890 - InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; Production { - lhs: 330, + lhs: 334, production: &[ - ParseType::N(509), - ParseType::N(331), - ParseType::N(355), - ParseType::N(334), + ParseType::N(521), + ParseType::N(335), + ParseType::N(359), + ParseType::N(338), + ParseType::N(337), + ParseType::N(254), ParseType::N(333), - ParseType::N(250), - ParseType::N(329), - ParseType::N(332), + ParseType::N(336), ], }, - // 881 - InterfaceDeclarationList: InterfaceGroup InterfaceDeclarationList; + // 891 - InterfaceDeclarationList: InterfaceGroup InterfaceDeclarationList; Production { - lhs: 331, - production: &[ParseType::N(331), ParseType::N(337)], + lhs: 335, + production: &[ParseType::N(335), ParseType::N(341)], }, - // 882 - InterfaceDeclarationList: ; + // 892 - InterfaceDeclarationList: ; Production { - lhs: 331, + lhs: 335, production: &[], }, - // 883 - InterfaceDeclarationOpt1: WithParameter; + // 893 - InterfaceDeclarationOpt1: WithParameter; Production { - lhs: 334, - production: &[ParseType::N(660)], + lhs: 338, + production: &[ParseType::N(671)], }, - // 884 - InterfaceDeclarationOpt1: ; + // 894 - InterfaceDeclarationOpt1: ; Production { - lhs: 334, + lhs: 338, production: &[], }, - // 885 - InterfaceDeclarationOpt0: WithGenericParameter; + // 895 - InterfaceDeclarationOpt0: WithGenericParameter; Production { - lhs: 333, - production: &[ParseType::N(654)], + lhs: 337, + production: &[ParseType::N(665)], }, - // 886 - InterfaceDeclarationOpt0: ; + // 896 - InterfaceDeclarationOpt0: ; Production { - lhs: 333, + lhs: 337, production: &[], }, - // 887 - InterfaceDeclarationOpt: Pub; + // 897 - InterfaceDeclarationOpt: Pub; Production { - lhs: 332, - production: &[ParseType::N(500)], + lhs: 336, + production: &[ParseType::N(512)], }, - // 888 - InterfaceDeclarationOpt: ; + // 898 - InterfaceDeclarationOpt: ; Production { - lhs: 332, + lhs: 336, production: &[], }, - // 889 - InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; + // 899 - InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; Production { - lhs: 341, + lhs: 345, production: &[ - ParseType::N(343), - ParseType::N(342), - ParseType::N(345), - ParseType::N(170), - ParseType::N(255), + ParseType::N(347), + ParseType::N(346), + ParseType::N(349), + ParseType::N(173), + ParseType::N(259), ], }, - // 890 - InterfaceIfDeclarationList: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; + // 900 - InterfaceIfDeclarationList: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; Production { - lhs: 342, + lhs: 346, production: &[ - ParseType::N(342), - ParseType::N(347), - ParseType::N(170), - ParseType::N(255), - ParseType::N(133), + ParseType::N(346), + ParseType::N(351), + ParseType::N(173), + ParseType::N(259), + ParseType::N(136), ], }, - // 891 - InterfaceIfDeclarationList: ; + // 901 - InterfaceIfDeclarationList: ; Production { - lhs: 342, + lhs: 346, production: &[], }, - // 892 - InterfaceIfDeclarationOpt: Else InterfaceOptionalNamedBlock; + // 902 - InterfaceIfDeclarationOpt: Else InterfaceOptionalNamedBlock; Production { - lhs: 343, - production: &[ParseType::N(347), ParseType::N(133)], + lhs: 347, + production: &[ParseType::N(351), ParseType::N(136)], }, - // 893 - InterfaceIfDeclarationOpt: ; + // 903 - InterfaceIfDeclarationOpt: ; Production { - lhs: 343, + lhs: 347, production: &[], }, - // 894 - InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; + // 904 - InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; Production { - lhs: 335, + lhs: 339, production: &[ - ParseType::N(345), - ParseType::N(336), - ParseType::N(518), - ParseType::N(280), - ParseType::N(250), - ParseType::N(220), + ParseType::N(349), + ParseType::N(340), + ParseType::N(530), + ParseType::N(284), + ParseType::N(254), + ParseType::N(223), ], }, - // 895 - InterfaceForDeclarationOpt: Step AssignmentOperator Expression; + // 905 - InterfaceForDeclarationOpt: Step AssignmentOperator Expression; Production { - lhs: 336, - production: &[ParseType::N(170), ParseType::N(42), ParseType::N(574)], + lhs: 340, + production: &[ParseType::N(173), ParseType::N(42), ParseType::N(587)], }, - // 896 - InterfaceForDeclarationOpt: ; + // 906 - InterfaceForDeclarationOpt: ; Production { - lhs: 336, + lhs: 340, production: &[], }, - // 897 - InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; + // 907 - InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; Production { - lhs: 345, + lhs: 349, production: &[ - ParseType::N(509), - ParseType::N(346), - ParseType::N(355), - ParseType::N(250), + ParseType::N(521), + ParseType::N(350), + ParseType::N(359), + ParseType::N(254), ParseType::N(92), ], }, - // 898 - InterfaceNamedBlockList: InterfaceGroup InterfaceNamedBlockList; + // 908 - InterfaceNamedBlockList: InterfaceGroup InterfaceNamedBlockList; Production { - lhs: 346, - production: &[ParseType::N(346), ParseType::N(337)], + lhs: 350, + production: &[ParseType::N(350), ParseType::N(341)], }, - // 899 - InterfaceNamedBlockList: ; + // 909 - InterfaceNamedBlockList: ; Production { - lhs: 346, + lhs: 350, production: &[], }, - // 900 - InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; + // 910 - InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; Production { - lhs: 347, + lhs: 351, production: &[ - ParseType::N(509), - ParseType::N(348), - ParseType::N(355), - ParseType::N(349), + ParseType::N(521), + ParseType::N(352), + ParseType::N(359), + ParseType::N(353), ], }, - // 901 - InterfaceOptionalNamedBlockList: InterfaceGroup InterfaceOptionalNamedBlockList; + // 911 - InterfaceOptionalNamedBlockList: InterfaceGroup InterfaceOptionalNamedBlockList; Production { - lhs: 348, - production: &[ParseType::N(348), ParseType::N(337)], + lhs: 352, + production: &[ParseType::N(352), ParseType::N(341)], }, - // 902 - InterfaceOptionalNamedBlockList: ; + // 912 - InterfaceOptionalNamedBlockList: ; Production { - lhs: 348, + lhs: 352, production: &[], }, - // 903 - InterfaceOptionalNamedBlockOpt: Colon Identifier; + // 913 - InterfaceOptionalNamedBlockOpt: Colon Identifier; Production { - lhs: 349, - production: &[ParseType::N(250), ParseType::N(92)], + lhs: 353, + production: &[ParseType::N(254), ParseType::N(92)], }, - // 904 - InterfaceOptionalNamedBlockOpt: ; + // 914 - InterfaceOptionalNamedBlockOpt: ; Production { - lhs: 349, + lhs: 353, production: &[], }, - // 905 - InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; + // 915 - InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; Production { - lhs: 337, - production: &[ParseType::N(338), ParseType::N(340)], + lhs: 341, + production: &[ParseType::N(342), ParseType::N(344)], }, - // 906 - InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; + // 916 - InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; Production { - lhs: 338, - production: &[ParseType::N(509), ParseType::N(339), ParseType::N(355)], + lhs: 342, + production: &[ParseType::N(521), ParseType::N(343), ParseType::N(359)], }, - // 907 - InterfaceGroupGroupList: InterfaceGroup InterfaceGroupGroupList; + // 917 - InterfaceGroupGroupList: InterfaceGroup InterfaceGroupGroupList; Production { - lhs: 339, - production: &[ParseType::N(339), ParseType::N(337)], + lhs: 343, + production: &[ParseType::N(343), ParseType::N(341)], }, - // 908 - InterfaceGroupGroupList: ; + // 918 - InterfaceGroupGroupList: ; Production { - lhs: 339, + lhs: 343, production: &[], }, - // 909 - InterfaceGroupGroup: InterfaceItem; + // 919 - InterfaceGroupGroup: InterfaceItem; Production { - lhs: 338, - production: &[ParseType::N(344)], + lhs: 342, + production: &[ParseType::N(348)], }, - // 910 - InterfaceGroupList: Attribute InterfaceGroupList; + // 920 - InterfaceGroupList: Attribute InterfaceGroupList; Production { - lhs: 340, - production: &[ParseType::N(340), ParseType::N(45)], + lhs: 344, + production: &[ParseType::N(344), ParseType::N(45)], }, - // 911 - InterfaceGroupList: ; + // 921 - InterfaceGroupList: ; Production { - lhs: 340, + lhs: 344, production: &[], }, - // 912 - InterfaceItem: LetDeclaration; + // 922 - InterfaceItem: LetDeclaration; Production { - lhs: 344, - production: &[ParseType::N(365)], + lhs: 348, + production: &[ParseType::N(369)], }, - // 913 - InterfaceItem: VarDeclaration; + // 923 - InterfaceItem: VarDeclaration; Production { - lhs: 344, - production: &[ParseType::N(637)], + lhs: 348, + production: &[ParseType::N(650)], }, - // 914 - InterfaceItem: LocalDeclaration; + // 924 - InterfaceItem: LocalDeclaration; Production { - lhs: 344, - production: &[ParseType::N(372)], + lhs: 348, + production: &[ParseType::N(376)], }, - // 915 - InterfaceItem: ModportDeclaration; + // 925 - InterfaceItem: ModportDeclaration; Production { - lhs: 344, - production: &[ParseType::N(389)], + lhs: 348, + production: &[ParseType::N(393)], }, - // 916 - InterfaceItem: InterfaceIfDeclaration; + // 926 - InterfaceItem: InterfaceIfDeclaration; Production { - lhs: 344, - production: &[ParseType::N(341)], + lhs: 348, + production: &[ParseType::N(345)], }, - // 917 - InterfaceItem: InterfaceForDeclaration; + // 927 - InterfaceItem: InterfaceForDeclaration; Production { - lhs: 344, - production: &[ParseType::N(335)], + lhs: 348, + production: &[ParseType::N(339)], }, - // 918 - InterfaceItem: TypeDefDeclaration; + // 928 - InterfaceItem: TypeDefDeclaration; Production { - lhs: 344, - production: &[ParseType::N(614)], + lhs: 348, + production: &[ParseType::N(627)], }, - // 919 - InterfaceItem: EnumDeclaration; + // 929 - InterfaceItem: EnumDeclaration; Production { - lhs: 344, - production: &[ParseType::N(146)], + lhs: 348, + production: &[ParseType::N(149)], }, - // 920 - InterfaceItem: StructUnionDeclaration; + // 930 - InterfaceItem: StructUnionDeclaration; Production { - lhs: 344, - production: &[ParseType::N(587)], + lhs: 348, + production: &[ParseType::N(600)], }, - // 921 - InterfaceItem: InterfaceNamedBlock; + // 931 - InterfaceItem: InterfaceNamedBlock; Production { - lhs: 344, - production: &[ParseType::N(345)], + lhs: 348, + production: &[ParseType::N(349)], }, - // 922 - InterfaceItem: FunctionDeclaration; + // 932 - InterfaceItem: FunctionDeclaration; Production { - lhs: 344, - production: &[ParseType::N(229)], + lhs: 348, + production: &[ParseType::N(232)], }, - // 923 - InterfaceItem: ImportDeclaration; + // 933 - InterfaceItem: ImportDeclaration; Production { - lhs: 344, - production: &[ParseType::N(276)], + lhs: 348, + production: &[ParseType::N(280)], }, - // 924 - InterfaceItem: InitialDeclaration; + // 934 - InterfaceItem: InitialDeclaration; Production { - lhs: 344, - production: &[ParseType::N(288)], + lhs: 348, + production: &[ParseType::N(292)], }, - // 925 - InterfaceItem: FinalDeclaration; + // 935 - InterfaceItem: FinalDeclaration; Production { - lhs: 344, - production: &[ParseType::N(212)], + lhs: 348, + production: &[ParseType::N(215)], }, - // 926 - PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace; + // 936 - PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace; Production { - lhs: 468, + lhs: 473, production: &[ - ParseType::N(509), - ParseType::N(469), - ParseType::N(355), - ParseType::N(471), - ParseType::N(250), - ParseType::N(467), - ParseType::N(470), + ParseType::N(521), + ParseType::N(474), + ParseType::N(359), + ParseType::N(476), + ParseType::N(254), + ParseType::N(472), + ParseType::N(475), ], }, - // 927 - PackageDeclarationList: PackageGroup PackageDeclarationList; + // 937 - PackageDeclarationList: PackageGroup PackageDeclarationList; Production { - lhs: 469, - production: &[ParseType::N(469), ParseType::N(472)], + lhs: 474, + production: &[ParseType::N(474), ParseType::N(477)], }, - // 928 - PackageDeclarationList: ; + // 938 - PackageDeclarationList: ; Production { - lhs: 469, + lhs: 474, production: &[], }, - // 929 - PackageDeclarationOpt0: WithGenericParameter; + // 939 - PackageDeclarationOpt0: WithGenericParameter; Production { - lhs: 471, - production: &[ParseType::N(654)], + lhs: 476, + production: &[ParseType::N(665)], }, - // 930 - PackageDeclarationOpt0: ; + // 940 - PackageDeclarationOpt0: ; Production { - lhs: 471, + lhs: 476, production: &[], }, - // 931 - PackageDeclarationOpt: Pub; + // 941 - PackageDeclarationOpt: Pub; Production { - lhs: 470, - production: &[ParseType::N(500)], + lhs: 475, + production: &[ParseType::N(512)], }, - // 932 - PackageDeclarationOpt: ; + // 942 - PackageDeclarationOpt: ; Production { - lhs: 470, + lhs: 475, production: &[], }, - // 933 - PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; + // 943 - PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; Production { - lhs: 472, - production: &[ParseType::N(473), ParseType::N(475)], + lhs: 477, + production: &[ParseType::N(478), ParseType::N(480)], }, - // 934 - PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; + // 944 - PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; Production { - lhs: 473, - production: &[ParseType::N(509), ParseType::N(474), ParseType::N(355)], + lhs: 478, + production: &[ParseType::N(521), ParseType::N(479), ParseType::N(359)], }, - // 935 - PackageGroupGroupList: PackageGroup PackageGroupGroupList; + // 945 - PackageGroupGroupList: PackageGroup PackageGroupGroupList; Production { - lhs: 474, - production: &[ParseType::N(474), ParseType::N(472)], + lhs: 479, + production: &[ParseType::N(479), ParseType::N(477)], }, - // 936 - PackageGroupGroupList: ; + // 946 - PackageGroupGroupList: ; Production { - lhs: 474, + lhs: 479, production: &[], }, - // 937 - PackageGroupGroup: PackageItem; + // 947 - PackageGroupGroup: PackageItem; Production { - lhs: 473, - production: &[ParseType::N(476)], + lhs: 478, + production: &[ParseType::N(481)], }, - // 938 - PackageGroupList: Attribute PackageGroupList; + // 948 - PackageGroupList: Attribute PackageGroupList; Production { - lhs: 475, - production: &[ParseType::N(475), ParseType::N(45)], + lhs: 480, + production: &[ParseType::N(480), ParseType::N(45)], }, - // 939 - PackageGroupList: ; + // 949 - PackageGroupList: ; Production { - lhs: 475, + lhs: 480, production: &[], }, - // 940 - PackageItem: VarDeclaration; + // 950 - PackageItem: VarDeclaration; Production { - lhs: 476, - production: &[ParseType::N(637)], + lhs: 481, + production: &[ParseType::N(650)], }, - // 941 - PackageItem: LocalDeclaration; + // 951 - PackageItem: LocalDeclaration; Production { - lhs: 476, - production: &[ParseType::N(372)], + lhs: 481, + production: &[ParseType::N(376)], }, - // 942 - PackageItem: TypeDefDeclaration; + // 952 - PackageItem: TypeDefDeclaration; Production { - lhs: 476, - production: &[ParseType::N(614)], + lhs: 481, + production: &[ParseType::N(627)], }, - // 943 - PackageItem: EnumDeclaration; + // 953 - PackageItem: EnumDeclaration; Production { - lhs: 476, - production: &[ParseType::N(146)], + lhs: 481, + production: &[ParseType::N(149)], }, - // 944 - PackageItem: StructUnionDeclaration; + // 954 - PackageItem: StructUnionDeclaration; Production { - lhs: 476, - production: &[ParseType::N(587)], + lhs: 481, + production: &[ParseType::N(600)], }, - // 945 - PackageItem: FunctionDeclaration; + // 955 - PackageItem: FunctionDeclaration; Production { - lhs: 476, - production: &[ParseType::N(229)], + lhs: 481, + production: &[ParseType::N(232)], }, - // 946 - PackageItem: ImportDeclaration; + // 956 - PackageItem: ImportDeclaration; Production { - lhs: 476, - production: &[ParseType::N(276)], + lhs: 481, + production: &[ParseType::N(280)], }, - // 947 - PackageItem: ExportDeclaration; + // 957 - PackageItem: ExportDeclaration; Production { - lhs: 476, - production: &[ParseType::N(165)], + lhs: 481, + production: &[ParseType::N(168)], }, - // 948 - PackageItem: InitialDeclaration; + // 958 - PackageItem: InitialDeclaration; Production { - lhs: 476, - production: &[ParseType::N(288)], + lhs: 481, + production: &[ParseType::N(292)], }, - // 949 - PackageItem: FinalDeclaration; + // 959 - PackageItem: FinalDeclaration; Production { - lhs: 476, - production: &[ParseType::N(212)], + lhs: 481, + production: &[ParseType::N(215)], }, - // 950 - EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; + // 960 - ProtoModuleDeclaration: ProtoModuleDeclarationOpt /* Option */ Proto Module Identifier ProtoModuleDeclarationOpt0 /* Option */ ProtoModuleDeclarationOpt1 /* Option */ Semicolon; Production { - lhs: 140, + lhs: 506, production: &[ - ParseType::N(137), - ParseType::N(250), - ParseType::N(515), - ParseType::N(250), - ParseType::N(361), - ParseType::N(136), + ParseType::N(575), + ParseType::N(509), + ParseType::N(508), + ParseType::N(254), + ParseType::N(403), + ParseType::N(505), + ParseType::N(507), ], }, - // 951 - EmbedContent: EmbedContentToken : crate::veryl_token::VerylToken ; + // 961 - ProtoModuleDeclarationOpt1: PortDeclaration; Production { - lhs: 137, - production: &[ParseType::N(138)], + lhs: 509, + production: &[ParseType::N(490)], }, - // 952 - EmbedContentToken: LBraceTerm Push(1) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm Pop Comments; + // 962 - ProtoModuleDeclarationOpt1: ; Production { - lhs: 138, + lhs: 509, + production: &[], + }, + // 963 - ProtoModuleDeclarationOpt0: WithParameter; + Production { + lhs: 508, + production: &[ParseType::N(671)], + }, + // 964 - ProtoModuleDeclarationOpt0: ; + Production { + lhs: 508, + production: &[], + }, + // 965 - ProtoModuleDeclarationOpt: Pub; + Production { + lhs: 507, + production: &[ParseType::N(512)], + }, + // 966 - ProtoModuleDeclarationOpt: ; + Production { + lhs: 507, + production: &[], + }, + // 967 - EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; + Production { + lhs: 143, + production: &[ + ParseType::N(140), + ParseType::N(254), + ParseType::N(527), + ParseType::N(254), + ParseType::N(365), + ParseType::N(139), + ], + }, + // 968 - EmbedContent: EmbedContentToken : crate::veryl_token::VerylToken ; + Production { + lhs: 140, + production: &[ParseType::N(141)], + }, + // 969 - EmbedContentToken: LBraceTerm Push(1) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm Pop Comments; + Production { + lhs: 141, production: &[ ParseType::N(104), ParseType::Pop, - ParseType::N(510), - ParseType::N(510), - ParseType::N(510), - ParseType::N(139), - ParseType::N(356), - ParseType::N(356), + ParseType::N(522), + ParseType::N(522), + ParseType::N(522), + ParseType::N(142), + ParseType::N(360), + ParseType::N(360), ParseType::Push(1), - ParseType::N(356), + ParseType::N(360), ], }, - // 953 - EmbedContentTokenList: EmbedItem EmbedContentTokenList; + // 970 - EmbedContentTokenList: EmbedItem EmbedContentTokenList; Production { - lhs: 139, - production: &[ParseType::N(139), ParseType::N(141)], + lhs: 142, + production: &[ParseType::N(142), ParseType::N(144)], }, - // 954 - EmbedContentTokenList: ; + // 971 - EmbedContentTokenList: ; Production { - lhs: 139, + lhs: 142, production: &[], }, - // 955 - EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; + // 972 - EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; Production { - lhs: 141, - production: &[ParseType::N(510), ParseType::N(142), ParseType::N(356)], + lhs: 144, + production: &[ParseType::N(522), ParseType::N(145), ParseType::N(360)], }, - // 956 - EmbedItemList: EmbedItem EmbedItemList; + // 973 - EmbedItemList: EmbedItem EmbedItemList; Production { - lhs: 142, - production: &[ParseType::N(142), ParseType::N(141)], + lhs: 145, + production: &[ParseType::N(145), ParseType::N(144)], }, - // 957 - EmbedItemList: ; + // 974 - EmbedItemList: ; Production { - lhs: 142, + lhs: 145, production: &[], }, - // 958 - EmbedItem: AnyTerm; + // 975 - EmbedItem: AnyTerm; Production { - lhs: 141, + lhs: 144, production: &[ParseType::N(18)], }, - // 959 - IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; + // 976 - IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; Production { - lhs: 284, + lhs: 288, production: &[ - ParseType::N(562), - ParseType::N(515), - ParseType::N(578), + ParseType::N(575), + ParseType::N(527), + ParseType::N(591), ParseType::N(101), - ParseType::N(250), - ParseType::N(361), - ParseType::N(283), + ParseType::N(254), + ParseType::N(365), + ParseType::N(287), ], }, - // 960 - DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; + // 977 - DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; Production { - lhs: 115, - production: &[ParseType::N(116), ParseType::N(118)], + lhs: 118, + production: &[ParseType::N(119), ParseType::N(121)], }, - // 961 - DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; + // 978 - DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; Production { - lhs: 116, - production: &[ParseType::N(509), ParseType::N(117), ParseType::N(355)], + lhs: 119, + production: &[ParseType::N(521), ParseType::N(120), ParseType::N(359)], }, - // 962 - DescriptionGroupGroupList: DescriptionGroup DescriptionGroupGroupList; + // 979 - DescriptionGroupGroupList: DescriptionGroup DescriptionGroupGroupList; Production { - lhs: 117, - production: &[ParseType::N(117), ParseType::N(115)], + lhs: 120, + production: &[ParseType::N(120), ParseType::N(118)], }, - // 963 - DescriptionGroupGroupList: ; + // 980 - DescriptionGroupGroupList: ; Production { - lhs: 117, + lhs: 120, production: &[], }, - // 964 - DescriptionGroupGroup: DescriptionItem; + // 981 - DescriptionGroupGroup: DescriptionItem; Production { - lhs: 116, - production: &[ParseType::N(119)], + lhs: 119, + production: &[ParseType::N(122)], }, - // 965 - DescriptionGroupList: Attribute DescriptionGroupList; + // 982 - DescriptionGroupList: Attribute DescriptionGroupList; Production { - lhs: 118, - production: &[ParseType::N(118), ParseType::N(45)], + lhs: 121, + production: &[ParseType::N(121), ParseType::N(45)], }, - // 966 - DescriptionGroupList: ; + // 983 - DescriptionGroupList: ; Production { - lhs: 118, + lhs: 121, production: &[], }, - // 967 - DescriptionItem: ModuleDeclaration; + // 984 - DescriptionItem: ModuleDeclaration; Production { - lhs: 119, - production: &[ParseType::N(400)], + lhs: 122, + production: &[ParseType::N(404)], }, - // 968 - DescriptionItem: InterfaceDeclaration; + // 985 - DescriptionItem: InterfaceDeclaration; Production { - lhs: 119, - production: &[ParseType::N(330)], + lhs: 122, + production: &[ParseType::N(334)], }, - // 969 - DescriptionItem: PackageDeclaration; + // 986 - DescriptionItem: PackageDeclaration; Production { - lhs: 119, - production: &[ParseType::N(468)], + lhs: 122, + production: &[ParseType::N(473)], }, - // 970 - DescriptionItem: ImportDeclaration; + // 987 - DescriptionItem: ProtoModuleDeclaration; Production { - lhs: 119, - production: &[ParseType::N(276)], + lhs: 122, + production: &[ParseType::N(506)], }, - // 971 - DescriptionItem: EmbedDeclaration; + // 988 - DescriptionItem: ImportDeclaration; Production { - lhs: 119, - production: &[ParseType::N(140)], + lhs: 122, + production: &[ParseType::N(280)], }, - // 972 - DescriptionItem: IncludeDeclaration; + // 989 - DescriptionItem: EmbedDeclaration; Production { - lhs: 119, - production: &[ParseType::N(284)], + lhs: 122, + production: &[ParseType::N(143)], }, - // 973 - Veryl: Start VerylList /* Vec */; + // 990 - DescriptionItem: IncludeDeclaration; Production { - lhs: 644, - production: &[ParseType::N(645), ParseType::N(571)], + lhs: 122, + production: &[ParseType::N(288)], }, - // 974 - VerylList: DescriptionGroup VerylList; + // 991 - Veryl: Start VerylList /* Vec */; Production { - lhs: 645, - production: &[ParseType::N(645), ParseType::N(115)], + lhs: 655, + production: &[ParseType::N(656), ParseType::N(584)], }, - // 975 - VerylList: ; + // 992 - VerylList: DescriptionGroup VerylList; Production { - lhs: 645, + lhs: 656, + production: &[ParseType::N(656), ParseType::N(118)], + }, + // 993 - VerylList: ; + Production { + lhs: 656, production: &[], }, ]; @@ -23006,7 +23274,7 @@ where T: AsRef, { let mut llk_parser = LLKParser::new( - 644, + 655, LOOKAHEAD_AUTOMATA, PRODUCTIONS, TERMINAL_NAMES, diff --git a/crates/parser/src/veryl_token.rs b/crates/parser/src/veryl_token.rs index 433e7b7f..93eaaf50 100644 --- a/crates/parser/src/veryl_token.rs +++ b/crates/parser/src/veryl_token.rs @@ -466,72 +466,72 @@ impl From<&FixedType> for TokenRange { impl From<&VariableType> for TokenRange { fn from(value: &VariableType) -> Self { - let mut range = match &*value.variable_type_group { - VariableTypeGroup::Clock(x) => { + match value { + VariableType::Clock(x) => { let beg = x.clock.clock_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::ClockPosedge(x) => { + VariableType::ClockPosedge(x) => { let beg = x.clock_posedge.clock_posedge_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::ClockNegedge(x) => { + VariableType::ClockNegedge(x) => { let beg = x.clock_negedge.clock_negedge_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::Reset(x) => { + VariableType::Reset(x) => { let beg = x.reset.reset_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::ResetAsyncHigh(x) => { + VariableType::ResetAsyncHigh(x) => { let beg = x.reset_async_high.reset_async_high_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::ResetAsyncLow(x) => { + VariableType::ResetAsyncLow(x) => { let beg = x.reset_async_low.reset_async_low_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::ResetSyncHigh(x) => { + VariableType::ResetSyncHigh(x) => { let beg = x.reset_sync_high.reset_sync_high_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::ResetSyncLow(x) => { + VariableType::ResetSyncLow(x) => { let beg = x.reset_sync_low.reset_sync_low_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::Logic(x) => { + VariableType::Logic(x) => { let beg = x.logic.logic_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::Bit(x) => { + VariableType::Bit(x) => { let beg = x.bit.bit_token.token; let end = beg; TokenRange { beg, end } } - VariableTypeGroup::ScopedIdentifier(x) => x.scoped_identifier.as_ref().into(), - }; - - if let Some(ref x) = value.variable_type_opt { - range.end = x.width.r_angle.r_angle_token.token; + VariableType::ScopedIdentifier(x) => x.scoped_identifier.as_ref().into(), } - - range } } impl From<&ScalarType> for TokenRange { fn from(value: &ScalarType) -> Self { let mut range: TokenRange = match &*value.scalar_type_group { - ScalarTypeGroup::VariableType(x) => x.variable_type.as_ref().into(), + ScalarTypeGroup::VariableTypeScalarTypeOpt(x) => { + let mut range: TokenRange = x.variable_type.as_ref().into(); + if let Some(ref x) = x.scalar_type_opt { + range.end = x.width.r_angle.r_angle_token.token; + } + range + } ScalarTypeGroup::FixedType(x) => x.fixed_type.as_ref().into(), }; @@ -881,6 +881,7 @@ token_with_comments!(Case); token_with_comments!(Clock); token_with_comments!(ClockPosedge); token_with_comments!(ClockNegedge); +token_with_comments!(Const); token_with_comments!(Default); token_with_comments!(Else); token_with_comments!(Embed); @@ -915,6 +916,7 @@ token_with_comments!(Output); token_with_comments!(Outside); token_with_comments!(Package); token_with_comments!(Param); +token_with_comments!(Proto); token_with_comments!(Pub); token_with_comments!(Ref); token_with_comments!(Repeat); diff --git a/crates/parser/src/veryl_walker.rs b/crates/parser/src/veryl_walker.rs index 0fad584d..89e851c2 100644 --- a/crates/parser/src/veryl_walker.rs +++ b/crates/parser/src/veryl_walker.rs @@ -398,6 +398,13 @@ pub trait VerylWalker { after!(self, clock_negedge, arg); } + /// Semantic action for non-terminal 'Const' + fn r#const(&mut self, arg: &Const) { + before!(self, r#const, arg); + self.veryl_token(&arg.const_token); + after!(self, r#const, arg); + } + /// Semantic action for non-terminal 'Defaul' fn defaul(&mut self, arg: &Defaul) { before!(self, defaul, arg); @@ -636,6 +643,13 @@ pub trait VerylWalker { after!(self, param, arg); } + /// Semantic action for non-terminal 'Proto' + fn proto(&mut self, arg: &Proto) { + before!(self, proto, arg); + self.veryl_token(&arg.proto_token); + after!(self, proto, arg); + } + /// Semantic action for non-terminal 'Pub' fn r#pub(&mut self, arg: &Pub) { before!(self, r#pub, arg); @@ -1409,22 +1423,19 @@ pub trait VerylWalker { /// Semantic action for non-terminal 'VariableType' fn variable_type(&mut self, arg: &VariableType) { before!(self, variable_type, arg); - match &*arg.variable_type_group { - VariableTypeGroup::Clock(x) => self.clock(&x.clock), - VariableTypeGroup::ClockPosedge(x) => self.clock_posedge(&x.clock_posedge), - VariableTypeGroup::ClockNegedge(x) => self.clock_negedge(&x.clock_negedge), - VariableTypeGroup::Reset(x) => self.reset(&x.reset), - VariableTypeGroup::ResetAsyncHigh(x) => self.reset_async_high(&x.reset_async_high), - VariableTypeGroup::ResetAsyncLow(x) => self.reset_async_low(&x.reset_async_low), - VariableTypeGroup::ResetSyncHigh(x) => self.reset_sync_high(&x.reset_sync_high), - VariableTypeGroup::ResetSyncLow(x) => self.reset_sync_low(&x.reset_sync_low), - VariableTypeGroup::Logic(x) => self.logic(&x.logic), - VariableTypeGroup::Bit(x) => self.bit(&x.bit), - VariableTypeGroup::ScopedIdentifier(x) => self.scoped_identifier(&x.scoped_identifier), + match arg { + VariableType::Clock(x) => self.clock(&x.clock), + VariableType::ClockPosedge(x) => self.clock_posedge(&x.clock_posedge), + VariableType::ClockNegedge(x) => self.clock_negedge(&x.clock_negedge), + VariableType::Reset(x) => self.reset(&x.reset), + VariableType::ResetAsyncHigh(x) => self.reset_async_high(&x.reset_async_high), + VariableType::ResetAsyncLow(x) => self.reset_async_low(&x.reset_async_low), + VariableType::ResetSyncHigh(x) => self.reset_sync_high(&x.reset_sync_high), + VariableType::ResetSyncLow(x) => self.reset_sync_low(&x.reset_sync_low), + VariableType::Logic(x) => self.logic(&x.logic), + VariableType::Bit(x) => self.bit(&x.bit), + VariableType::ScopedIdentifier(x) => self.scoped_identifier(&x.scoped_identifier), }; - if let Some(ref x) = arg.variable_type_opt { - self.width(&x.width); - } after!(self, variable_type, arg); } @@ -1445,7 +1456,12 @@ pub trait VerylWalker { self.type_modifier(&x.type_modifier); } match &*arg.scalar_type_group { - ScalarTypeGroup::VariableType(x) => self.variable_type(&x.variable_type), + ScalarTypeGroup::VariableTypeScalarTypeOpt(x) => { + self.variable_type(&x.variable_type); + if let Some(ref x) = x.scalar_type_opt { + self.width(&x.width); + } + } ScalarTypeGroup::FixedType(x) => self.fixed_type(&x.fixed_type), } after!(self, scalar_type, arg); @@ -2302,6 +2318,17 @@ pub trait VerylWalker { after!(self, with_parameter_item, arg); } + /// Semantic action for non-terminal 'GenericBound' + fn generic_bound(&mut self, arg: &GenericBound) { + before!(self, generic_bound, arg); + match arg { + GenericBound::Const(x) => self.r#const(&x.r#const), + GenericBound::Type(x) => self.r#type(&x.r#type), + GenericBound::ScopedIdentifier(x) => self.scoped_identifier(&x.scoped_identifier), + } + after!(self, generic_bound, arg); + } + /// Semantic action for non-terminal 'WithGenericParameter' fn with_generic_parameter(&mut self, arg: &WithGenericParameter) { before!(self, with_generic_parameter, arg); @@ -2329,6 +2356,8 @@ pub trait VerylWalker { fn with_generic_parameter_item(&mut self, arg: &WithGenericParameterItem) { before!(self, with_generic_parameter_item, arg); self.identifier(&arg.identifier); + self.colon(&arg.colon); + self.generic_bound(&arg.generic_bound); if let Some(ref x) = arg.with_generic_parameter_item_opt { self.equ(&x.equ); self.with_generic_argument_item(&x.with_generic_argument_item); @@ -2560,9 +2589,13 @@ pub trait VerylWalker { self.with_generic_parameter(&x.with_generic_parameter); } if let Some(ref x) = arg.module_declaration_opt1 { - self.with_parameter(&x.with_parameter); + self.r#for(&x.r#for); + self.scoped_identifier(&x.scoped_identifier); } if let Some(ref x) = arg.module_declaration_opt2 { + self.with_parameter(&x.with_parameter); + } + if let Some(ref x) = arg.module_declaration_opt3 { self.port_declaration(&x.port_declaration); } self.l_brace(&arg.l_brace); @@ -2897,6 +2930,24 @@ pub trait VerylWalker { after!(self, package_item, arg); } + /// Semantic action for non-terminal 'ProtoModuleDeclaration' + fn proto_module_declaration(&mut self, arg: &ProtoModuleDeclaration) { + before!(self, proto_module_declaration, arg); + if let Some(ref x) = arg.proto_module_declaration_opt { + self.r#pub(&x.r#pub); + } + self.module(&arg.module); + self.identifier(&arg.identifier); + if let Some(ref x) = arg.proto_module_declaration_opt0 { + self.with_parameter(&x.with_parameter); + } + if let Some(ref x) = arg.proto_module_declaration_opt1 { + self.port_declaration(&x.port_declaration); + } + self.semicolon(&arg.semicolon); + after!(self, proto_module_declaration, arg); + } + /// Semantic action for non-terminal 'EmbedDeclaration' fn embed_declaration(&mut self, arg: &EmbedDeclaration) { before!(self, embed_declaration, arg); @@ -2959,6 +3010,9 @@ pub trait VerylWalker { DescriptionItem::PackageDeclaration(x) => { self.package_declaration(&x.package_declaration) } + DescriptionItem::ProtoModuleDeclaration(x) => { + self.proto_module_declaration(&x.proto_module_declaration) + } DescriptionItem::ImportDeclaration(x) => self.import_declaration(&x.import_declaration), DescriptionItem::EmbedDeclaration(x) => self.embed_declaration(&x.embed_declaration), DescriptionItem::IncludeDeclaration(x) => { diff --git a/crates/parser/veryl.par b/crates/parser/veryl.par index bdea7088..8bb9784c 100644 --- a/crates/parser/veryl.par +++ b/crates/parser/veryl.par @@ -74,6 +74,7 @@ CaseTerm : /(?-u:\b)case(?-u:\b)/ ClockTerm : /(?-u:\b)clock(?-u:\b)/ : Token; ClockPosedgeTerm : /(?-u:\b)clock_posedge(?-u:\b)/ : Token; ClockNegedgeTerm : /(?-u:\b)clock_negedge(?-u:\b)/ : Token; +ConstTerm : /(?-u:\b)const(?-u:\b)/ : Token; DefaultTerm : /(?-u:\b)default(?-u:\b)/ : Token; ElseTerm : /(?-u:\b)else(?-u:\b)/ : Token; EmbedTerm : /(?-u:\b)embed(?-u:\b)/ : Token; @@ -108,6 +109,7 @@ OutputTerm : /(?-u:\b)output(?-u:\b)/ OutsideTerm : /(?-u:\b)outside(?-u:\b)/ : Token; PackageTerm : /(?-u:\b)package(?-u:\b)/ : Token; ParamTerm : /(?-u:\b)param(?-u:\b)/ : Token; +ProtoTerm : /(?-u:\b)proto(?-u:\b)/ : Token; PubTerm : /(?-u:\b)pub(?-u:\b)/ : Token; RefTerm : /(?-u:\b)ref(?-u:\b)/ : Token; RepeatTerm : /(?-u:\b)repeat(?-u:\b)/ : Token; @@ -198,6 +200,7 @@ CaseToken : CaseTerm : Token Comments; ClockToken : ClockTerm : Token Comments; ClockPosedgeToken : ClockPosedgeTerm : Token Comments; ClockNegedgeToken : ClockNegedgeTerm : Token Comments; +ConstToken : ConstTerm : Token Comments; DefaultToken : DefaultTerm : Token Comments; ElseToken : ElseTerm : Token Comments; EmbedToken : EmbedTerm : Token Comments; @@ -232,6 +235,7 @@ OutputToken : OutputTerm : Token Comments; OutsideToken : OutsideTerm : Token Comments; PackageToken : PackageTerm : Token Comments; ParamToken : ParamTerm : Token Comments; +ProtoToken : ProtoTerm : Token Comments; PubToken : PubTerm : Token Comments; RefToken : RefTerm : Token Comments; RepeatToken : RepeatTerm : Token Comments; @@ -327,6 +331,7 @@ Case : CaseToken : VerylToken; Clock : ClockToken : VerylToken; ClockPosedge : ClockPosedgeToken : VerylToken; ClockNegedge : ClockNegedgeToken : VerylToken; +Const : ConstToken : VerylToken; Defaul : DefaultToken : VerylToken; // avoid to conflict with Rust's Default trait Else : ElseToken : VerylToken; Embed : EmbedToken : VerylToken; @@ -361,6 +366,7 @@ Output : OutputToken : VerylToken; Outside : OutsideToken : VerylToken; Package : PackageToken : VerylToken; Param : ParamToken : VerylToken; +Proto : ProtoToken : VerylToken; Pub : PubToken : VerylToken; Ref : RefToken : VerylToken; Repeat : RepeatToken : VerylToken; @@ -504,22 +510,21 @@ RangeOperator: DotDot FixedType: U32 | U64 | I32 | I64 | F32 | F64 | Strin; -VariableType: ( Clock - | ClockPosedge - | ClockNegedge - | Reset - | ResetAsyncHigh - | ResetAsyncLow - | ResetSyncHigh - | ResetSyncLow - | Logic - | Bit - | ScopedIdentifier - ) [ Width ]; +VariableType: Clock + | ClockPosedge + | ClockNegedge + | Reset + | ResetAsyncHigh + | ResetAsyncLow + | ResetSyncHigh + | ResetSyncLow + | Logic + | Bit + | ScopedIdentifier; TypeModifier: Tri | Signed; -ScalarType: { TypeModifier } ( VariableType | FixedType ); +ScalarType: { TypeModifier } ( VariableType [ Width ] | FixedType ); ArrayType: ScalarType [ Array ]; @@ -691,11 +696,15 @@ WithParameterItem: ( Param | Local ) Identifier Colon ( ArrayType Equ Expression // WithGenericParameter // ---------------------------------------------------------------------------- +GenericBound: Const + | Type + | ScopedIdentifier; + WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; WithGenericParameterList: WithGenericParameterItem { Comma WithGenericParameterItem } [ Comma ]; -WithGenericParameterItem: Identifier [ Equ WithGenericArgumentItem ]; +WithGenericParameterItem: Identifier Colon GenericBound [ Equ WithGenericArgumentItem ]; // ---------------------------------------------------------------------------- // WithGenericArgument @@ -761,7 +770,7 @@ UnsafeBlock: Unsafe LParen Identifier RParen LBrace { ModuleGroup } RBrace; // Module // ---------------------------------------------------------------------------- -ModuleDeclaration: [ Pub ] Module Identifier [ WithGenericParameter ] [ WithParameter ] [ PortDeclaration ] LBrace { ModuleGroup } RBrace; +ModuleDeclaration: [ Pub ] Module Identifier [ WithGenericParameter ] [ For ScopedIdentifier ] [ WithParameter ] [ PortDeclaration ] LBrace { ModuleGroup } RBrace; ModuleIfDeclaration: If Expression ModuleNamedBlock { Else If Expression ModuleOptionalNamedBlock } [ Else ModuleOptionalNamedBlock ]; @@ -845,6 +854,12 @@ PackageItem: VarDeclaration | FinalDeclaration ; +// ---------------------------------------------------------------------------- +// Proto +// ---------------------------------------------------------------------------- + +ProtoModuleDeclaration: [ Pub ] Proto Module Identifier [ WithParameter ] [ PortDeclaration ] Semicolon; + // ---------------------------------------------------------------------------- // Embed // ---------------------------------------------------------------------------- @@ -873,6 +888,7 @@ DescriptionGroup: { Attribute } ( LBrace { DescriptionGroup } RBrace | Descripti DescriptionItem: ModuleDeclaration | InterfaceDeclaration | PackageDeclaration + | ProtoModuleDeclaration | ImportDeclaration | EmbedDeclaration | IncludeDeclaration diff --git a/crates/veryl/src/cmd_doc.rs b/crates/veryl/src/cmd_doc.rs index ec8d820d..b32c886c 100644 --- a/crates/veryl/src/cmd_doc.rs +++ b/crates/veryl/src/cmd_doc.rs @@ -46,6 +46,7 @@ impl CmdDoc { } let mut modules = BTreeMap::new(); + let mut proto_modules = BTreeMap::new(); let mut interfaces = BTreeMap::new(); let mut packages = BTreeMap::new(); @@ -64,6 +65,15 @@ impl CmdDoc { }; modules.insert(text, item); } + SymbolKind::ProtoModule(_) => { + let html_name = file_name.clone(); + let item = TopLevelItem { + file_name, + html_name, + symbol, + }; + proto_modules.insert(text, item); + } SymbolKind::Interface(x) => { let html_name = fmt_generic_parameters(&text, &x.generic_parameters); let item = TopLevelItem { @@ -88,10 +98,11 @@ impl CmdDoc { } let modules: Vec<_> = modules.into_values().collect(); + let proto_modules: Vec<_> = proto_modules.into_values().collect(); let interfaces: Vec<_> = interfaces.into_values().collect(); let packages: Vec<_> = packages.into_values().collect(); - let builder = DocBuilder::new(metadata, modules, interfaces, packages)?; + let builder = DocBuilder::new(metadata, modules, proto_modules, interfaces, packages)?; builder.build()?; Ok(true) diff --git a/crates/veryl/src/doc/doc_builder.rs b/crates/veryl/src/doc/doc_builder.rs index 0e7b0dec..a8a421ba 100644 --- a/crates/veryl/src/doc/doc_builder.rs +++ b/crates/veryl/src/doc/doc_builder.rs @@ -11,7 +11,6 @@ use tempfile::TempDir; use veryl_analyzer::symbol::{ClockDomain, ParameterScope, Symbol, SymbolKind}; use veryl_analyzer::symbol_table; use veryl_metadata::Metadata; -use veryl_parser::resource_table; use veryl_parser::veryl_token::Token; const SUMMARY_TMPL: &str = r###" @@ -27,6 +26,11 @@ const SUMMARY_TMPL: &str = r###" - [{{this.0}}]({{this.1}}.md) {{/each}} +- [Module Prototypes](proto_modules.md) + {{#each proto_modules}} + - [{{this.0}}]({{this.1}}.md) + {{/each}} + - [Interfaces](interfaces.md) {{#each interfaces}} - [{{this.0}}]({{this.1}}.md) @@ -43,6 +47,7 @@ struct SummaryData { name: String, version: String, modules: Vec<(String, String)>, + proto_modules: Vec<(String, String)>, interfaces: Vec<(String, String)>, packages: Vec<(String, String)>, } @@ -75,6 +80,7 @@ const INDEX_TMPL: &str = r###" {{{{raw}}}} {{#include modules.md}} +{{#include proto_modules.md}} {{#include interfaces.md}} {{#include packages.md}} {{{{/raw}}}} @@ -97,7 +103,7 @@ const LIST_TMPL: &str = r###" {{#each items}} - {{this.name}} + {{this.html_name}} {{this.description}} {{/each}} @@ -114,7 +120,8 @@ struct ListData { #[derive(Serialize)] struct ListItem { - name: String, + file_name: String, + html_name: String, description: String, } @@ -123,6 +130,22 @@ const MODULE_TMPL: &str = r#" {{description}} +{{#if generic_parameters}} +### Generic Parameters +--- + + + +{{#each generic_parameters}} + + + + +{{/each}} + +
{{this.name}}{{this.bound}}
+{{/if}} + {{#if parameters}} ### Parameters --- @@ -181,11 +204,18 @@ const MODULE_TMPL: &str = r#" struct ModuleData { name: String, description: String, + generic_parameters: Vec, parameters: Vec, clock_domains: Vec, ports: Vec, } +#[derive(Serialize)] +struct GenericParameterData { + name: String, + bound: String, +} + #[derive(Serialize)] struct ParameterData { name: String, @@ -202,6 +232,74 @@ struct PortData { description: Option, } +const PROTO_MODULE_TMPL: &str = r#" +## {{name}} + +{{description}} + +{{#if parameters}} +### Parameters +--- + + + +{{#each parameters}} + + + + + +{{/each}} + +
{{this.name}}{{this.typ}}{{this.description}}
+{{/if}} + +{{#if clock_domains}} +### Clock Domains +--- + + + +{{#each clock_domains}} + + + +{{/each}} + +
{{this}}
+{{/if}} + +{{#if ports}} +### Ports +--- + + + +{{#each ports}} + + + + {{#if ../clock_domains}} + + {{/if}} + + + +{{/each}} + +
{{this.name}}{{this.direction}}{{this.clock_domain}}{{this.typ}}{{this.description}}
+{{/if}} +"#; + +#[derive(Serialize)] +struct ProtoModuleData { + name: String, + description: String, + parameters: Vec, + clock_domains: Vec, + ports: Vec, +} + const INTERFACE_TMPL: &str = r#" ## {{name}} @@ -253,6 +351,7 @@ pub struct DocBuilder { src_dir: PathBuf, theme_dir: PathBuf, modules: Vec, + proto_modules: Vec, interfaces: Vec, packages: Vec, } @@ -268,6 +367,7 @@ impl DocBuilder { pub fn new( metadata: &Metadata, modules: Vec, + proto_modules: Vec, interfaces: Vec, packages: Vec, ) -> Result { @@ -285,6 +385,7 @@ impl DocBuilder { src_dir, theme_dir, modules, + proto_modules, interfaces, packages, }) @@ -296,6 +397,7 @@ impl DocBuilder { self.build_component("SUMMARY.md", self.build_summary())?; self.build_component("index.md", self.build_index())?; self.build_component("modules.md", self.build_modules())?; + self.build_component("proto_modules.md", self.build_proto_modules())?; self.build_component("interfaces.md", self.build_interfaces())?; self.build_component("packages.md", self.build_packages())?; @@ -304,6 +406,11 @@ impl DocBuilder { self.build_component(&file, self.build_module(&x.html_name, &x.symbol))?; } + for x in &self.proto_modules { + let file = format!("{}.md", x.file_name); + self.build_component(&file, self.build_proto_module(&x.html_name, &x.symbol))?; + } + for x in &self.interfaces { let file = format!("{}.md", x.file_name); self.build_component(&file, self.build_interface(&x.html_name, &x.symbol))?; @@ -405,6 +512,12 @@ impl DocBuilder { .cloned() .map(|x| (x.html_name, x.file_name)) .collect(); + let proto_modules: Vec<_> = self + .proto_modules + .iter() + .cloned() + .map(|x| (x.html_name, x.file_name)) + .collect(); let interfaces: Vec<_> = self .interfaces .iter() @@ -421,6 +534,7 @@ impl DocBuilder { name: self.metadata.project.name.clone(), version: format!("{}", self.metadata.project.version), modules, + proto_modules, interfaces, packages, }; @@ -449,7 +563,8 @@ impl DocBuilder { .modules .iter() .map(|x| ListItem { - name: x.html_name.clone(), + file_name: x.file_name.clone(), + html_name: x.html_name.clone(), description: x.symbol.doc_comment.format(true), }) .collect(); @@ -464,12 +579,34 @@ impl DocBuilder { handlebars.render_template(LIST_TMPL, &data).unwrap() } + fn build_proto_modules(&self) -> String { + let items: Vec<_> = self + .proto_modules + .iter() + .map(|x| ListItem { + file_name: x.file_name.clone(), + html_name: x.html_name.clone(), + description: x.symbol.doc_comment.format(true), + }) + .collect(); + + let data = ListData { + name: "Module Prototypes".to_string(), + items, + }; + + let mut handlebars = Handlebars::new(); + handlebars.register_escape_fn(handlebars::no_escape); + handlebars.render_template(LIST_TMPL, &data).unwrap() + } + fn build_interfaces(&self) -> String { let items: Vec<_> = self .interfaces .iter() .map(|x| ListItem { - name: x.html_name.clone(), + file_name: x.file_name.clone(), + html_name: x.html_name.clone(), description: x.symbol.doc_comment.format(true), }) .collect(); @@ -489,7 +626,8 @@ impl DocBuilder { .packages .iter() .map(|x| ListItem { - name: x.html_name.clone(), + file_name: x.file_name.clone(), + html_name: x.html_name.clone(), description: x.symbol.doc_comment.format(true), }) .collect(); @@ -506,12 +644,28 @@ impl DocBuilder { fn build_module(&self, name: &str, symbol: &Symbol) -> String { if let SymbolKind::Module(property) = &symbol.kind { + let generic_parameters: Vec<_> = property + .generic_parameters + .iter() + .filter_map(|x| { + let symbol = symbol_table::get(*x).unwrap(); + if let SymbolKind::GenericParameter(x) = symbol.kind { + Some(GenericParameterData { + name: symbol.token.text.to_string(), + bound: x.bound.to_string(), + }) + } else { + None + } + }) + .collect(); + let parameters: Vec<_> = property .parameters .iter() .filter(|x| matches!(x.property().scope, ParameterScope::Global,)) .map(|x| ParameterData { - name: resource_table::get_str_value(x.name).unwrap(), + name: x.name.to_string(), typ: format!("{}", x.property().r#type), description: get_comment_from_token(&x.property().token), }) @@ -541,7 +695,7 @@ impl DocBuilder { None }; PortData { - name: resource_table::get_str_value(x.name).unwrap(), + name: x.name.to_string(), direction: format!("{}", x.property().direction), clock_domain, typ: x.property().r#type.as_ref().map(|x| format!("{}", x)), @@ -553,6 +707,7 @@ impl DocBuilder { let data = ModuleData { name: name.to_string(), description: symbol.doc_comment.format(false), + generic_parameters, parameters, clock_domains, ports, @@ -566,6 +721,70 @@ impl DocBuilder { } } + fn build_proto_module(&self, name: &str, symbol: &Symbol) -> String { + if let SymbolKind::ProtoModule(property) = &symbol.kind { + let parameters: Vec<_> = property + .parameters + .iter() + .filter(|x| matches!(x.property().scope, ParameterScope::Global,)) + .map(|x| ParameterData { + name: x.name.to_string(), + typ: format!("{}", x.property().r#type), + description: get_comment_from_token(&x.property().token), + }) + .collect(); + + let clock_domains: HashSet<_> = property + .ports + .iter() + .filter_map(|x| { + if let ClockDomain::Explicit(_) = x.property().clock_domain { + Some(x.property().clock_domain.to_string()) + } else { + None + } + }) + .collect(); + let mut clock_domains: Vec<_> = clock_domains.into_iter().collect(); + clock_domains.sort(); + + let ports: Vec<_> = property + .ports + .iter() + .map(|x| { + let clock_domain = if let ClockDomain::Explicit(_) = x.property().clock_domain { + Some(x.property().clock_domain.to_string()) + } else { + None + }; + PortData { + name: x.name.to_string(), + direction: format!("{}", x.property().direction), + clock_domain, + typ: x.property().r#type.as_ref().map(|x| format!("{}", x)), + description: get_comment_from_token(&x.property().token), + } + }) + .collect(); + + let data = ProtoModuleData { + name: name.to_string(), + description: symbol.doc_comment.format(false), + parameters, + clock_domains, + ports, + }; + + let mut handlebars = Handlebars::new(); + handlebars.register_escape_fn(handlebars::no_escape); + handlebars + .render_template(PROTO_MODULE_TMPL, &data) + .unwrap() + } else { + String::new() + } + } + fn build_interface(&self, name: &str, symbol: &Symbol) -> String { if let SymbolKind::Interface(property) = &symbol.kind { let parameters: Vec<_> = property @@ -573,7 +792,7 @@ impl DocBuilder { .iter() .filter(|x| matches!(x.property().scope, ParameterScope::Global,)) .map(|x| ParameterData { - name: resource_table::get_str_value(x.name).unwrap(), + name: x.name.to_string(), typ: format!("{}", x.property().r#type), description: get_comment_from_token(&x.property().token), }) diff --git a/support/vim b/support/vim index 031b5426..e7b3c19b 160000 --- a/support/vim +++ b/support/vim @@ -1 +1 @@ -Subproject commit 031b5426aad9077ae7d9d5261455e53f83be6383 +Subproject commit e7b3c19bd0837befdd98db0ab5a10cf620b982c7 diff --git a/testcases/map/testcases/sv/54_generic_function.sv.map b/testcases/map/testcases/sv/54_generic_function.sv.map index 1b883324..7b7377f9 100644 --- a/testcases/map/testcases/sv/54_generic_function.sv.map +++ b/testcases/map/testcases/sv/54_generic_function.sv.map @@ -1 +1 @@ -{"version":3,"file":"54_generic_function.sv.map","sources":["../../../veryl/54_generic_function.veryl"],"names":["","module","Module54",";","function","logic","[","10","]","(","input","a",")","return","+","1","endfunction","20","_a","=","__FuncA__10","_b","__FuncA__20","2","4","12","_c","__FuncB__10__2","14","_d","__FuncB__10__4","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZC,mBAEKC,MAAKC,CAACC,MAACC,aAFQC;QACbC,MAAML,MAAKC,CAACC,MAACC,EAAhBG,CAAiBX;IACrBY,EAAEZ,CAAYA;QACVa,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;IAJAZ,mBAEKC,MAAKC,CAACW,MAACT,aAFQC;QACbC,MAAML,MAAKC,CAACW,MAACT,EAAhBG,CAAiBX;IACrBY,EAAEZ,CAAYA;QACVa,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;;IAEQX,MAAKC,CAACC,MAAEC,EAAZU;mBAAcC,EAAEC,WAAWX,CAACM,CAACH,CAACT;IAC1BE,MAAKC,CAACW,MAAET,EAAZa;mBAAcF,EAAEG,WAAWb,CAACM,CAACH,CAACT;;IAElCC,mBAEKC,MAAKC,CAACC,GAAEO,EAAES,KAACf,gBAFWC;QACpBC,MAAML,MAAKC,CAACC,GAAEO,EAAES,KAACf,EAApBG,CAAqBX;IACzBY,EAAEZ,CAAgBA;QACda,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;IAJAZ,mBAEKC,MAAKC,CAACC,GAAEO,EAAEU,KAAChB,gBAFWC;QACpBC,MAAML,MAAKC,CAACC,GAAEO,EAAEU,KAAChB,EAApBG,CAAqBX;IACzBY,EAAEZ,CAAgBA;QACda,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;;IAEQX,MAAKC,CAACmB,MAAEjB,EAAZkB;mBAAcP,EAAEQ,cAAWlB,CAACM,CAACH,CAACT;IAC1BE,MAAKC,CAACsB,MAAEpB,EAAZqB;mBAAcV,EAAEW,cAAcrB,CAACM,CAACH,CAACT;AACzC4B"} \ No newline at end of file +{"version":3,"file":"54_generic_function.sv.map","sources":["../../../veryl/54_generic_function.veryl"],"names":["","module","Module54",";","function","logic","[","10","]","(","input","a",")","return","+","1","endfunction","20","_a","=","__FuncA__10","_b","__FuncA__20","2","4","12","_c","__FuncB__10__2","14","_d","__FuncB__10__4","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZC,mBAEKC,MAAKC,CAACC,MAACC,aAFeC;QACpBC,MAAML,MAAKC,CAACC,MAACC,EAAhBG,CAAiBX;IACrBY,EAAEZ,CAAYA;QACVa,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;IAJAZ,mBAEKC,MAAKC,CAACW,MAACT,aAFeC;QACpBC,MAAML,MAAKC,CAACW,MAACT,EAAhBG,CAAiBX;IACrBY,EAAEZ,CAAYA;QACVa,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;;IAEQX,MAAKC,CAACC,MAAEC,EAAZU;mBAAcC,EAAEC,WAAWX,CAACM,CAACH,CAACT;IAC1BE,MAAKC,CAACW,MAAET,EAAZa;mBAAcF,EAAEG,WAAWb,CAACM,CAACH,CAACT;;IAElCC,mBAEKC,MAAKC,CAACC,GAAEO,EAAES,KAACf,gBAFyBC;QAClCC,MAAML,MAAKC,CAACC,GAAEO,EAAES,KAACf,EAApBG,CAAqBX;IACzBY,EAAEZ,CAAgBA;QACda,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;IAJAZ,mBAEKC,MAAKC,CAACC,GAAEO,EAAEU,KAAChB,gBAFyBC;QAClCC,MAAML,MAAKC,CAACC,GAAEO,EAAEU,KAAChB,EAApBG,CAAqBX;IACzBY,EAAEZ,CAAgBA;QACda,OAAOF,EAAEG,EAAEC,CAACZ;IAChBa;;IAEQX,MAAKC,CAACmB,MAAEjB,EAAZkB;mBAAcP,EAAEQ,cAAWlB,CAACM,CAACH,CAACT;IAC1BE,MAAKC,CAACsB,MAAEpB,EAAZqB;mBAAcV,EAAEW,cAAcrB,CAACM,CAACH,CAACT;AACzC4B"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/55_generic_module.sv.map b/testcases/map/testcases/sv/55_generic_module.sv.map index 1b6805c6..d1dac27d 100644 --- a/testcases/map/testcases/sv/55_generic_module.sv.map +++ b/testcases/map/testcases/sv/55_generic_module.sv.map @@ -1 +1 @@ -{"version":3,"file":"55_generic_module.sv.map","sources":["../../../veryl/55_generic_module.veryl"],"names":["","module","Module55",";","veryl_testcase___Module55A__Module55B","u0","veryl_testcase___Module55A__Module55C","u1","veryl_testcase___Module55E__Module55C","u2","veryl_testcase___Module55E__Module55D","u3","veryl_testcase___Module55F__Module55C","u4","veryl_testcase___Module55F__Module55B","u5","endmodule","veryl_testcase_Module55B","u","veryl_testcase_Module55C","veryl_testcase_Module55D","Module55B","Module55C","Module55D","veryl_testcase___Module55A__Module55D"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZH,AAASI,sCAAJC,KAA0BF;IAC/BH,AAASM,sCAAJC,KAA0BJ;IAC/BH,AAASQ,sCAAJC,KAA0BN;IAC/BH,AAASU,sCAAJC,KAA0BR;IAC/BH,AAASY,sCAAJC,KAA0BV;IAC/BH,AAASc,sCAAJC,KAAiBZ;AAC1Ba;;;AAGIf,4CAAsBE;IACtBH,AAAQiB,yBAAHC,IAAIf;AACba;AAFIf,4CAAsBE;IACtBH,AAAQmB,yBAAHD,IAAIf;AACba;AAFIf,4CAAsBE;IACtBH,AAAQoB,yBAAHF,IAAIf;AACba;;AAEAf,sBAAOoB,SAAUlB;AAACa;;AAElBf,sBAAOqB,SAAUnB;AAACa;;AAElBf,sBAAOsB,SAAUpB;AAACa;;AAElBf,4CAAsBE;IAClBH,AAAQM,sCAAHY,IAAiBf;AAC1Ba;AAFAf,4CAAsBE;IAClBH,AAAQwB,sCAAHN,IAAiBf;AAC1Ba;;AAEAf,4CAAkCE;IAC9BH,AAAQmB,yBAAHD,IAAIf;AACba;AAFAf,4CAAkCE;IAC9BH,AAAQiB,yBAAHC,IAAIf;AACba"} \ No newline at end of file +{"version":3,"file":"55_generic_module.sv.map","sources":["../../../veryl/55_generic_module.veryl"],"names":["","module","Module55",";","veryl_testcase___Module55A__Module55B","u0","veryl_testcase___Module55A__Module55C","u1","veryl_testcase___Module55E__Module55C","u2","veryl_testcase___Module55E__Module55D","u3","veryl_testcase___Module55F__Module55C","u4","veryl_testcase___Module55F__Module55B","u5","endmodule","veryl_testcase_Module55B","u","veryl_testcase_Module55C","veryl_testcase_Module55D","Module55B","Module55C","Module55D","veryl_testcase___Module55A__Module55D"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZH,AAASI,sCAAJC,KAA0BF;IAC/BH,AAASM,sCAAJC,KAA0BJ;IAC/BH,AAASQ,sCAAJC,KAA0BN;IAC/BH,AAASU,sCAAJC,KAA0BR;IAC/BH,AAASY,sCAAJC,KAA0BV;IAC/BH,AAASc,sCAAJC,KAAiBZ;AAC1Ba;;;AAKIf,4CAA+BE;IAC/BH,AAAQiB,yBAAHC,IAAIf;AACba;AAFIf,4CAA+BE;IAC/BH,AAAQmB,yBAAHD,IAAIf;AACba;AAFIf,4CAA+BE;IAC/BH,AAAQoB,yBAAHF,IAAIf;AACba;;AAEAf,sBAAOoB,SAAsBlB;AAACa;;AAE9Bf,sBAAOqB,SAAsBnB;AAACa;;AAE9Bf,sBAAOsB,SAAsBpB;AAACa;;AAE9Bf,4CAA+BE;IAC3BH,AAAQM,sCAAHY,IAAiBf;AAC1Ba;AAFAf,4CAA+BE;IAC3BH,AAAQwB,sCAAHN,IAAiBf;AAC1Ba;;AAEAf,4CAA2CE;IACvCH,AAAQmB,yBAAHD,IAAIf;AACba;AAFAf,4CAA2CE;IACvCH,AAAQiB,yBAAHC,IAAIf;AACba"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/56_generic_interface.sv.map b/testcases/map/testcases/sv/56_generic_interface.sv.map index 81d6a81d..b4a4c272 100644 --- a/testcases/map/testcases/sv/56_generic_interface.sv.map +++ b/testcases/map/testcases/sv/56_generic_interface.sv.map @@ -1 +1 @@ -{"version":3,"file":"56_generic_interface.sv.map","sources":["../../../veryl/56_generic_interface.veryl"],"names":["","module","Module56",";","veryl_testcase___Interface56A__Package56A","u0","veryl_testcase___Interface56A__Package56B","u1","veryl_testcase___Interface56B__Package56A","u2","veryl_testcase___Interface56B__Package56B","u3","endmodule","interface","logic","[","veryl_testcase_Package56A::X","]","_a","endinterface","veryl_testcase_Package56B::X","_b","package","Package56A","localparam","int unsigned","X","=","1","endpackage","Package56B","2"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZH,AAASI,0CAAJC,KAA8BF;IACnCH,AAASM,0CAAJC,KAA8BJ;IACnCH,AAASQ,0CAAJC,KAA8BN;IACnCH,AAASU,0CAAJC,KAAoBR;AAC7BS;;;AAGIC,mDAA4BV;IACpBW,MAAKC,CAACC,gCAAIC,EAAdC,EAAef;AACvBgB;;;AAFIN,mDAA4BV;IACpBW,MAAKC,CAACK,gCAAIH,EAAdC,EAAef;AACvBgB;;;AAGIN,mDAAyCV;IACjCW,MAAKC,CAACC,gCAAIC,EAAdI,EAAelB;AACvBgB;AAFIN,mDAAyCV;IACjCW,MAAKC,CAACK,gCAAIH,EAAdI,EAAelB;AACvBgB;;AAEAG,uBAAQC,UAAWpB;IACfqB,WAASC,aAAHC,EAAOC,EAAEC,CAACzB;AACpB0B;;AAEAP,uBAAQQ,UAAW3B;IACfqB,WAASC,aAAHC,EAAOC,EAAEI,CAAC5B;AACpB0B"} \ No newline at end of file +{"version":3,"file":"56_generic_interface.sv.map","sources":["../../../veryl/56_generic_interface.veryl"],"names":["","module","Module56",";","veryl_testcase___Interface56A__Package56A","u0","veryl_testcase___Interface56A__Package56B","u1","veryl_testcase___Interface56B__Package56A","u2","veryl_testcase___Interface56B__Package56B","u3","endmodule","interface","logic","[","veryl_testcase_Package56A::X","]","_a","endinterface","veryl_testcase_Package56B::X","_b","package","Package56A","localparam","int unsigned","X","=","1","endpackage","Package56B","2"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZH,AAASI,0CAAJC,KAA8BF;IACnCH,AAASM,0CAAJC,KAA8BJ;IACnCH,AAASQ,0CAAJC,KAA8BN;IACnCH,AAASU,0CAAJC,KAAoBR;AAC7BS;;;AAGIC,mDAAmCV;IAC3BW,MAAKC,CAACC,gCAAIC,EAAdC,EAAef;AACvBgB;;;AAFIN,mDAAmCV;IAC3BW,MAAKC,CAACK,gCAAIH,EAAdC,EAAef;AACvBgB;;;AAGIN,mDAAgDV;IACxCW,MAAKC,CAACC,gCAAIC,EAAdI,EAAelB;AACvBgB;AAFIN,mDAAgDV;IACxCW,MAAKC,CAACK,gCAAIH,EAAdI,EAAelB;AACvBgB;;AAEAG,uBAAQC,UAAWpB;IACfqB,WAASC,aAAHC,EAAOC,EAAEC,CAACzB;AACpB0B;;AAEAP,uBAAQQ,UAAW3B;IACfqB,WAASC,aAAHC,EAAOC,EAAEI,CAAC5B;AACpB0B"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/57_generic_package.sv.map b/testcases/map/testcases/sv/57_generic_package.sv.map index 716fa8b9..41d0e222 100644 --- a/testcases/map/testcases/sv/57_generic_package.sv.map +++ b/testcases/map/testcases/sv/57_generic_package.sv.map @@ -1 +1 @@ -{"version":3,"file":"57_generic_package.sv.map","sources":["../../../veryl/57_generic_package.veryl"],"names":["","module","Module57",";","localparam","int unsigned","A","=","veryl_testcase___Package57A__1::X","longint unsigned","B","veryl_testcase___Package57A__2::X","C","veryl_testcase___Package57B__3::X","D","veryl_testcase___Package57B__4::X","veryl_testcase___Package57C__2::StructC","_e","always_comb",".","c","1","endmodule","package","X","endpackage","2","3","4","typedef struct packed","{","logic","[","]","StructC"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZC,WAASC,iBAAHC,EAAOC,EAAEC,iCAAkBL;IACjCC,WAASK,iBAAHC,EAAOH,EAAEI,iCAAkBR;IACjCC,WAASC,iBAAHO,EAAOL,EAAEM,iCAAkBV;IACjCC,WAASK,iBAAHK,EAAOP,EAAEQ,iCAAiBZ;;IAEtBa,wCAANC,IAA8Bd;IAClCe,YAAOD,EAAEE,CAACC,EAAEb,EAAEc,CAAClB;AACnBmB;;;AAGIC,sCAAwBpB;IACxBC,WAASC,aAAHmB,EAAOjB,EAAEc,CAAClB;AACpBsB;;;AAFIF,sCAAwBpB;IACxBC,WAASC,aAAHmB,EAAOjB,EAAEmB,CAACvB;AACpBsB;;;AAGIF,sCAA4BpB;IAC5BC,WAASC,aAAHmB,EAAOjB,EAAEoB,CAACxB;AACpBsB;AAFIF,sCAA4BpB;IAC5BC,WAASC,aAAHmB,EAAOjB,EAAEqB,CAACzB;AACpBsB;;AAEAF,sCAAwBpB;IACpB0B,sBAAeC;QACRC,MAAKC,CAACN,KAACO,EAAVb,CAAWjB;MADR+B,QAEPlC;AACJyB"} \ No newline at end of file +{"version":3,"file":"57_generic_package.sv.map","sources":["../../../veryl/57_generic_package.veryl"],"names":["","module","Module57",";","localparam","int unsigned","A","=","veryl_testcase___Package57A__1::X","longint unsigned","B","veryl_testcase___Package57A__2::X","C","veryl_testcase___Package57B__3::X","D","veryl_testcase___Package57B__4::X","veryl_testcase___Package57C__2::StructC","_e","always_comb",".","c","1","endmodule","package","X","endpackage","2","3","4","typedef struct packed","{","logic","[","]","StructC"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZC,WAASC,iBAAHC,EAAOC,EAAEC,iCAAkBL;IACjCC,WAASK,iBAAHC,EAAOH,EAAEI,iCAAkBR;IACjCC,WAASC,iBAAHO,EAAOL,EAAEM,iCAAkBV;IACjCC,WAASK,iBAAHK,EAAOP,EAAEQ,iCAAiBZ;;IAEtBa,wCAANC,IAA8Bd;IAClCe,YAAOD,EAAEE,CAACC,EAAEb,EAAEc,CAAClB;AACnBmB;;;AAGIC,sCAA+BpB;IAC/BC,WAASC,aAAHmB,EAAOjB,EAAEc,CAAClB;AACpBsB;;;AAFIF,sCAA+BpB;IAC/BC,WAASC,aAAHmB,EAAOjB,EAAEmB,CAACvB;AACpBsB;;;AAGIF,sCAAmCpB;IACnCC,WAASC,aAAHmB,EAAOjB,EAAEoB,CAACxB;AACpBsB;AAFIF,sCAAmCpB;IACnCC,WAASC,aAAHmB,EAAOjB,EAAEqB,CAACzB;AACpBsB;;AAEAF,sCAA+BpB;IAC3B0B,sBAAeC;QACRC,MAAKC,CAACN,KAACO,EAAVb,CAAWjB;MADR+B,QAEPlC;AACJyB"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/58_generic_struct.sv.map b/testcases/map/testcases/sv/58_generic_struct.sv.map index 91b02d19..9d827023 100644 --- a/testcases/map/testcases/sv/58_generic_struct.sv.map +++ b/testcases/map/testcases/sv/58_generic_struct.sv.map @@ -1 +1 @@ -{"version":3,"file":"58_generic_struct.sv.map","sources":["../../../veryl/58_generic_struct.veryl"],"names":["","module","Module58",";","typedef struct packed","{","veryl_testcase_Package58::B","A","veryl_testcase_Package58::C","C","typedef","int signed","B","__StructA__Package58_B","_a","__StructA__Package58_C","_b","__StructA__C","_c","__StructB__Package58_C","_d","__StructB__C","_e","endmodule","package","Package58","int unsigned","longint unsigned","endpackage"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZC,sBAAoBC;QACbC,4BAAHC,CAAIJ;6BACRH;IAFAI,sBAAoBC;QACbG,4BAAHD,CAAIJ;6BACRH;IAFAI,sBAAoBC;QACbI,EAAHF,CAAIJ;mBACRH;;IAEAU,QAASC,WAAJF,CAAON;;IAEZC,sBAAwBC;QACjBG,4BAAHI,CAAIT;6BACRH;IAFAI,sBAAwBC;QACjBI,EAAHG,CAAIT;mBACRH;;IAEQa,uBAAJC,EAA2BX;IACvBY,uBAAJC,EAA2Bb;IACvBc,uBAAJC,EAA2Bf;IACvBgB,uBAAJC,EAA2BjB;IACvBkB,aAAJC,EAA2BnB;AACnCoB;;AAEAC,uBAAQC,SAAUtB;IACdO,QAASgB,iBAAJd,CAAOT;IACZO,QAASiB,iBAAJlB,CAAON;AAChByB"} \ No newline at end of file +{"version":3,"file":"58_generic_struct.sv.map","sources":["../../../veryl/58_generic_struct.veryl"],"names":["","module","Module58",";","typedef struct packed","{","veryl_testcase_Package58::B","A","veryl_testcase_Package58::C","C","typedef","int signed","B","__StructA__Package58_B","_a","__StructA__Package58_C","_b","__StructA__C","_c","__StructB__Package58_C","_d","__StructB__C","_e","endmodule","package","Package58","int unsigned","longint unsigned","endpackage"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZC,sBAA0BC;QACnBC,4BAAHC,CAAIJ;6BACRH;IAFAI,sBAA0BC;QACnBG,4BAAHD,CAAIJ;6BACRH;IAFAI,sBAA0BC;QACnBI,EAAHF,CAAIJ;mBACRH;;IAEAU,QAASC,WAAJF,CAAON;;IAEZC,sBAA8BC;QACvBG,4BAAHI,CAAIT;6BACRH;IAFAI,sBAA8BC;QACvBI,EAAHG,CAAIT;mBACRH;;IAEQa,uBAAJC,EAA2BX;IACvBY,uBAAJC,EAA2Bb;IACvBc,uBAAJC,EAA2Bf;IACvBgB,uBAAJC,EAA2BjB;IACvBkB,aAAJC,EAA2BnB;AACnCoB;;AAEAC,uBAAQC,SAAUtB;IACdO,QAASgB,iBAAJd,CAAOT;IACZO,QAASiB,iBAAJlB,CAAON;AAChByB"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/69_proto.sv.map b/testcases/map/testcases/sv/69_proto.sv.map new file mode 100644 index 00000000..02db11a2 --- /dev/null +++ b/testcases/map/testcases/sv/69_proto.sv.map @@ -0,0 +1 @@ +{"version":3,"file":"69_proto.sv.map","sources":["../../../veryl/69_proto.veryl"],"names":["","module","Module69A","#","(","parameter","int unsigned","A","=","1",",","B","C",")","input","logic","a","b","output","c",";","always_comb","endmodule"],"mappings":"AAAAA;;;AAkBAC,sBAAOC,UAAsBC,CAACC;IAC1BC,UAASC,aAAHC,EAAOC,EAAEC,CAACC;IAChBL,UAASC,aAAHK,EAAOH,EAAEC,CAACC;IAChBL,UAASC,aAAHM,EAAOJ,EAAEC,CAACT;AACpBa,EAAET;IACKU,OAAOC,MAAVC,CAAeN;IACZI,OAAOC,MAAVE,CAAeP;IACZQ,OAAOH,MAAVI,CAAenB;AACnBa,CAAEO;IACEC,YAAOF,EAAEX,EAAEQ,CAACI;AAChBE"} \ No newline at end of file diff --git a/testcases/sv/55_generic_module.sv b/testcases/sv/55_generic_module.sv index 283de5ab..c390fab4 100644 --- a/testcases/sv/55_generic_module.sv +++ b/testcases/sv/55_generic_module.sv @@ -7,7 +7,7 @@ module veryl_testcase_Module55; veryl_testcase___Module55F__Module55B u5 (); endmodule -/// Generic module test for doc comment + module veryl_testcase___Module55A__Module55B; veryl_testcase_Module55B u (); endmodule diff --git a/testcases/sv/69_proto.sv b/testcases/sv/69_proto.sv new file mode 100644 index 00000000..875b5d05 --- /dev/null +++ b/testcases/sv/69_proto.sv @@ -0,0 +1,15 @@ + + + +module veryl_testcase_Module69A #( + parameter int unsigned A = 1, + parameter int unsigned B = 1, + parameter int unsigned C = 1 +) ( + input logic a, + input logic b, + output logic c +); + always_comb c = a; +endmodule +//# sourceMappingURL=../map/testcases/sv/69_proto.sv.map diff --git a/testcases/veryl/54_generic_function.veryl b/testcases/veryl/54_generic_function.veryl index f0ae7ac1..abb2bb98 100644 --- a/testcases/veryl/54_generic_function.veryl +++ b/testcases/veryl/54_generic_function.veryl @@ -1,5 +1,5 @@ module Module54 { - function FuncA:: ( + function FuncA:: ( a: input logic, ) -> logic { return a + 1; @@ -8,7 +8,7 @@ module Module54 { let _a: logic<10> = FuncA::<10>(1); let _b: logic<20> = FuncA::<20>(1); - function FuncB:: ( + function FuncB:: ( a: input logic, ) -> logic { return a + 1; diff --git a/testcases/veryl/55_generic_module.veryl b/testcases/veryl/55_generic_module.veryl index 49b7b532..bb14fc0e 100644 --- a/testcases/veryl/55_generic_module.veryl +++ b/testcases/veryl/55_generic_module.veryl @@ -7,25 +7,27 @@ module Module55 { inst u5: Module55F::<>; } +pub proto module Proto55; + /// Generic module test for doc comment -pub module Module55A:: { +pub module Module55A:: { inst u: T; } -module Module55B {} +module Module55B for Proto55 {} -module Module55C {} +module Module55C for Proto55 {} -module Module55D {} +module Module55D for Proto55 {} -module Module55E:: { +module Module55E:: { inst u: Module55A::; } -module Module55F:: { +module Module55F:: { inst u: T; } -module Module55G:: { +module Module55G:: { inst u: T; } diff --git a/testcases/veryl/56_generic_interface.veryl b/testcases/veryl/56_generic_interface.veryl index d7c3b9c5..ec08f793 100644 --- a/testcases/veryl/56_generic_interface.veryl +++ b/testcases/veryl/56_generic_interface.veryl @@ -6,12 +6,12 @@ module Module56 { } /// Generic interface test for doc comment -pub interface Interface56A:: { +pub interface Interface56A:: { var _a: logic; } /// Generic interface test for doc comment -pub interface Interface56B:: { +pub interface Interface56B:: { var _b: logic; } diff --git a/testcases/veryl/57_generic_package.veryl b/testcases/veryl/57_generic_package.veryl index 33c8c6d9..d6d6650b 100644 --- a/testcases/veryl/57_generic_package.veryl +++ b/testcases/veryl/57_generic_package.veryl @@ -9,16 +9,16 @@ module Module57 { } /// Generic package test for doc comment -pub package Package57A:: { +pub package Package57A:: { local X: u32 = T; } /// Generic package test for doc comment -pub package Package57B:: { +pub package Package57B:: { local X: u32 = T; } -package Package57C:: { +package Package57C:: { struct StructC { c: logic, } diff --git a/testcases/veryl/58_generic_struct.veryl b/testcases/veryl/58_generic_struct.veryl index 7eff0c57..ca7af13b 100644 --- a/testcases/veryl/58_generic_struct.veryl +++ b/testcases/veryl/58_generic_struct.veryl @@ -1,11 +1,11 @@ module Module58 { - struct StructA:: { + struct StructA:: { A: T, } type C = i32; - struct StructB:: { + struct StructB:: { B: T, } diff --git a/testcases/veryl/69_proto.veryl b/testcases/veryl/69_proto.veryl new file mode 100644 index 00000000..a5af4c7f --- /dev/null +++ b/testcases/veryl/69_proto.veryl @@ -0,0 +1,29 @@ +module Module69:: { + inst u: T ( + a: 0, + b: 0, + c: _, + ); +} + +proto module Proto69 #( + param A: u32 = 1, + param B: u32 = 1, + param C: u32 = 1, +) ( + a: input logic, + b: input logic, + c: output logic, +); + +module Module69A for Proto69 #( + param A: u32 = 1, + param B: u32 = 1, + param C: u32 = 1, +) ( + a: input logic, + b: input logic, + c: output logic, +) { + assign c = a; +}