diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs
index 24346f16..d67dc77a 100644
--- a/rusty_lr_parser/src/emit.rs
+++ b/rusty_lr_parser/src/emit.rs
@@ -679,7 +679,7 @@ impl Grammar {
                     let new_index = terminal_sets_name_map.len();
                     terminal_sets_name_map
                         .entry(set)
-                        .or_insert_with(|| format_ident!("__rustylr_tset{new_index}"))
+                        .or_insert_with(|| format_ident!("__RUSTYLR_TSET{new_index}"))
                         .clone()
                 };
             for state in &self.states {
@@ -743,6 +743,7 @@ impl Grammar {
 
                 let mut ruleset_rules_body_stream = TokenStream::new();
                 let mut ruleset_shifted_body_stream = TokenStream::new();
+                let ruleset_len = state.ruleset.len();
                 let mut max_shifted = 0;
                 for &rule in &state.ruleset {
                     max_shifted = max_shifted.max(rule.shifted);
@@ -765,23 +766,31 @@ impl Grammar {
                     quote! { usize }
                 };
 
+                let reduce_map_construct_stream = if reduce_body_stream.is_empty() {
+                    quote! { Default::default() }
+                } else {
+                    quote! {
+                        {
+                        let mut __reduce_map = std::collections::BTreeMap::new();
+                        #reduce_body_stream
+                        __reduce_map.into_iter().collect()
+                        }
+                    }
+                };
+
                 states_body_stream.extend(quote! {
                     #module_prefix::parser::state::IntermediateState {
                         shift_goto_map_term: vec![#shift_term_body_stream],
                         shift_goto_map_nonterm: vec![#shift_nonterm_body_stream],
-                        reduce_map: {
-                            let mut __reduce_map = std::collections::BTreeMap::new();
-                            #reduce_body_stream
-                            __reduce_map.into_iter().collect()
-                        },
+                        reduce_map: #reduce_map_construct_stream,
                         ruleset: {
-                            let rules: &'static [#rule_index_typename] = &[
+                            static __RULES: [#rule_index_typename; #ruleset_len] = [
                                 #ruleset_rules_body_stream
                             ];
-                            let shifted: &'static [#shifted_typename] = &[
+                            static __SHIFTED: [#shifted_typename; #ruleset_len] = [
                                 #ruleset_shifted_body_stream
                             ];
-                            rules.iter().zip(shifted.iter()).map(
+                            __RULES.iter().zip(__SHIFTED.iter()).map(
                                 |(&rule, &shifted)| {
                                     #module_prefix::rule::ShiftedRuleRef {
                                         rule: rule as usize,
@@ -796,6 +805,7 @@ impl Grammar {
 
             let mut terminal_set_initialize_stream = TokenStream::new();
             for (set, name) in terminal_sets_name_map {
+                let len = set.len();
                 let set_it = set.into_iter().map(|val| match val {
                     TerminalSymbol::Term(term) => {
                         let var = &class_variants[term];
@@ -811,7 +821,7 @@ impl Grammar {
                     }
                 });
                 terminal_set_initialize_stream.extend(quote! {
-                    let #name: Vec<#termclass_typename> = vec![#(#set_it),*];
+                    static #name: [#termclass_typename; #len] = [#(#set_it),*];
                 });
             }
 
diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs
index 04151a50..e9763e6b 100644
--- a/rusty_lr_parser/src/parser/parser_expanded.rs
+++ b/rusty_lr_parser/src/parser/parser_expanded.rs
@@ -7311,132 +7311,204 @@ impl GrammarParser {
             ::rusty_lr_core::Token::Term(GrammarTerminalClasses::eof),], precedence :
             None, },
         ];
-        let __rustylr_tset17: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::colon,
-            GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe,
-            GrammarTerminalClasses::percent, GrammarTerminalClasses::equal,
-            GrammarTerminalClasses::plus, GrammarTerminalClasses::star,
-            GrammarTerminalClasses::question, GrammarTerminalClasses::caret,
-            GrammarTerminalClasses::minus, GrammarTerminalClasses::exclamation,
-            GrammarTerminalClasses::slash, GrammarTerminalClasses::dot,
-            GrammarTerminalClasses::dollar, GrammarTerminalClasses::comma,
-            GrammarTerminalClasses::literal, GrammarTerminalClasses::parengroup,
-            GrammarTerminalClasses::bracegroup, GrammarTerminalClasses::lparen,
-            GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket,
-            GrammarTerminalClasses::rbracket, GrammarTerminalClasses::left,
-            GrammarTerminalClasses::right, GrammarTerminalClasses::token,
-            GrammarTerminalClasses::start, GrammarTerminalClasses::tokentype,
-            GrammarTerminalClasses::userdata, GrammarTerminalClasses::errortype,
-            GrammarTerminalClasses::moduleprefix, GrammarTerminalClasses::lalr,
-            GrammarTerminalClasses::glr, GrammarTerminalClasses::prec,
-            GrammarTerminalClasses::precedence, GrammarTerminalClasses::nooptim,
-            GrammarTerminalClasses::dense, GrammarTerminalClasses::trace,
-            GrammarTerminalClasses::dprec, GrammarTerminalClasses::filter,
+        static __RUSTYLR_TSET17: [GrammarTerminalClasses; 42usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::colon,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::equal,
+            GrammarTerminalClasses::plus,
+            GrammarTerminalClasses::star,
+            GrammarTerminalClasses::question,
+            GrammarTerminalClasses::caret,
+            GrammarTerminalClasses::minus,
+            GrammarTerminalClasses::exclamation,
+            GrammarTerminalClasses::slash,
+            GrammarTerminalClasses::dot,
+            GrammarTerminalClasses::dollar,
+            GrammarTerminalClasses::comma,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::parengroup,
+            GrammarTerminalClasses::bracegroup,
+            GrammarTerminalClasses::lparen,
+            GrammarTerminalClasses::rparen,
+            GrammarTerminalClasses::lbracket,
+            GrammarTerminalClasses::rbracket,
+            GrammarTerminalClasses::left,
+            GrammarTerminalClasses::right,
+            GrammarTerminalClasses::token,
+            GrammarTerminalClasses::start,
+            GrammarTerminalClasses::tokentype,
+            GrammarTerminalClasses::userdata,
+            GrammarTerminalClasses::errortype,
+            GrammarTerminalClasses::moduleprefix,
+            GrammarTerminalClasses::lalr,
+            GrammarTerminalClasses::glr,
+            GrammarTerminalClasses::prec,
+            GrammarTerminalClasses::precedence,
+            GrammarTerminalClasses::nooptim,
+            GrammarTerminalClasses::dense,
+            GrammarTerminalClasses::trace,
+            GrammarTerminalClasses::dprec,
+            GrammarTerminalClasses::filter,
             GrammarTerminalClasses::location,
-            GrammarTerminalClasses::__rustylr_other_terminals
+            GrammarTerminalClasses::__rustylr_other_terminals,
         ];
-        let __rustylr_tset19: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon
+        static __RUSTYLR_TSET19: [GrammarTerminalClasses; 2usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
         ];
-        let __rustylr_tset3: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon,
-            GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent,
-            GrammarTerminalClasses::plus, GrammarTerminalClasses::star,
-            GrammarTerminalClasses::question, GrammarTerminalClasses::minus,
-            GrammarTerminalClasses::exclamation, GrammarTerminalClasses::slash,
-            GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar,
-            GrammarTerminalClasses::comma, GrammarTerminalClasses::literal,
-            GrammarTerminalClasses::bracegroup, GrammarTerminalClasses::lparen,
-            GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket,
-            GrammarTerminalClasses::error
+        static __RUSTYLR_TSET3: [GrammarTerminalClasses; 19usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::plus,
+            GrammarTerminalClasses::star,
+            GrammarTerminalClasses::question,
+            GrammarTerminalClasses::minus,
+            GrammarTerminalClasses::exclamation,
+            GrammarTerminalClasses::slash,
+            GrammarTerminalClasses::dot,
+            GrammarTerminalClasses::dollar,
+            GrammarTerminalClasses::comma,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::bracegroup,
+            GrammarTerminalClasses::lparen,
+            GrammarTerminalClasses::rparen,
+            GrammarTerminalClasses::lbracket,
+            GrammarTerminalClasses::error,
         ];
-        let __rustylr_tset2: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon,
-            GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent,
-            GrammarTerminalClasses::plus, GrammarTerminalClasses::star,
-            GrammarTerminalClasses::question, GrammarTerminalClasses::minus,
-            GrammarTerminalClasses::exclamation, GrammarTerminalClasses::slash,
-            GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar,
-            GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup,
-            GrammarTerminalClasses::lparen, GrammarTerminalClasses::lbracket
+        static __RUSTYLR_TSET2: [GrammarTerminalClasses; 16usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::plus,
+            GrammarTerminalClasses::star,
+            GrammarTerminalClasses::question,
+            GrammarTerminalClasses::minus,
+            GrammarTerminalClasses::exclamation,
+            GrammarTerminalClasses::slash,
+            GrammarTerminalClasses::dot,
+            GrammarTerminalClasses::dollar,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::bracegroup,
+            GrammarTerminalClasses::lparen,
+            GrammarTerminalClasses::lbracket,
         ];
-        let __rustylr_tset8: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon,
-            GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent,
-            GrammarTerminalClasses::minus, GrammarTerminalClasses::slash,
-            GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar,
-            GrammarTerminalClasses::comma, GrammarTerminalClasses::literal,
-            GrammarTerminalClasses::bracegroup, GrammarTerminalClasses::lparen,
-            GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket,
-            GrammarTerminalClasses::error
+        static __RUSTYLR_TSET8: [GrammarTerminalClasses; 15usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::minus,
+            GrammarTerminalClasses::slash,
+            GrammarTerminalClasses::dot,
+            GrammarTerminalClasses::dollar,
+            GrammarTerminalClasses::comma,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::bracegroup,
+            GrammarTerminalClasses::lparen,
+            GrammarTerminalClasses::rparen,
+            GrammarTerminalClasses::lbracket,
+            GrammarTerminalClasses::error,
         ];
-        let __rustylr_tset7: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon,
-            GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent,
-            GrammarTerminalClasses::minus, GrammarTerminalClasses::dot,
-            GrammarTerminalClasses::dollar, GrammarTerminalClasses::comma,
-            GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup,
-            GrammarTerminalClasses::lparen, GrammarTerminalClasses::rparen,
-            GrammarTerminalClasses::lbracket, GrammarTerminalClasses::error
+        static __RUSTYLR_TSET7: [GrammarTerminalClasses; 14usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::minus,
+            GrammarTerminalClasses::dot,
+            GrammarTerminalClasses::dollar,
+            GrammarTerminalClasses::comma,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::bracegroup,
+            GrammarTerminalClasses::lparen,
+            GrammarTerminalClasses::rparen,
+            GrammarTerminalClasses::lbracket,
+            GrammarTerminalClasses::error,
         ];
-        let __rustylr_tset11: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon,
-            GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent,
-            GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar,
-            GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup,
-            GrammarTerminalClasses::lparen, GrammarTerminalClasses::lbracket
+        static __RUSTYLR_TSET11: [GrammarTerminalClasses; 10usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::dot,
+            GrammarTerminalClasses::dollar,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::bracegroup,
+            GrammarTerminalClasses::lparen,
+            GrammarTerminalClasses::lbracket,
         ];
-        let __rustylr_tset15: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon,
-            GrammarTerminalClasses::pipe, GrammarTerminalClasses::percent,
-            GrammarTerminalClasses::literal, GrammarTerminalClasses::bracegroup
+        static __RUSTYLR_TSET15: [GrammarTerminalClasses; 6usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::bracegroup,
         ];
-        let __rustylr_tset16: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::semicolon,
-            GrammarTerminalClasses::literal
+        static __RUSTYLR_TSET16: [GrammarTerminalClasses; 3usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::literal,
         ];
-        let __rustylr_tset9: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::pipe,
-            GrammarTerminalClasses::dot, GrammarTerminalClasses::dollar,
-            GrammarTerminalClasses::literal, GrammarTerminalClasses::lparen,
-            GrammarTerminalClasses::rparen, GrammarTerminalClasses::lbracket
+        static __RUSTYLR_TSET9: [GrammarTerminalClasses; 8usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::dot,
+            GrammarTerminalClasses::dollar,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::lparen,
+            GrammarTerminalClasses::rparen,
+            GrammarTerminalClasses::lbracket,
         ];
-        let __rustylr_tset12: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::percent,
-            GrammarTerminalClasses::eof
+        static __RUSTYLR_TSET12: [GrammarTerminalClasses; 3usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::eof,
         ];
-        let __rustylr_tset5: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::ident, GrammarTerminalClasses::literal,
-            GrammarTerminalClasses::rbracket
+        static __RUSTYLR_TSET5: [GrammarTerminalClasses; 3usize] = [
+            GrammarTerminalClasses::ident,
+            GrammarTerminalClasses::literal,
+            GrammarTerminalClasses::rbracket,
         ];
-        let __rustylr_tset0: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::colon
+        static __RUSTYLR_TSET0: [GrammarTerminalClasses; 1usize] = [
+            GrammarTerminalClasses::colon,
         ];
-        let __rustylr_tset18: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::semicolon
+        static __RUSTYLR_TSET18: [GrammarTerminalClasses; 1usize] = [
+            GrammarTerminalClasses::semicolon,
         ];
-        let __rustylr_tset13: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe
+        static __RUSTYLR_TSET13: [GrammarTerminalClasses; 2usize] = [
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
         ];
-        let __rustylr_tset1: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe,
-            GrammarTerminalClasses::percent, GrammarTerminalClasses::bracegroup
+        static __RUSTYLR_TSET1: [GrammarTerminalClasses; 4usize] = [
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::percent,
+            GrammarTerminalClasses::bracegroup,
         ];
-        let __rustylr_tset14: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::semicolon, GrammarTerminalClasses::pipe,
-            GrammarTerminalClasses::bracegroup
+        static __RUSTYLR_TSET14: [GrammarTerminalClasses; 3usize] = [
+            GrammarTerminalClasses::semicolon,
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::bracegroup,
         ];
-        let __rustylr_tset4: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::pipe, GrammarTerminalClasses::rparen
+        static __RUSTYLR_TSET4: [GrammarTerminalClasses; 2usize] = [
+            GrammarTerminalClasses::pipe,
+            GrammarTerminalClasses::rparen,
         ];
-        let __rustylr_tset10: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::rparen
+        static __RUSTYLR_TSET10: [GrammarTerminalClasses; 1usize] = [
+            GrammarTerminalClasses::rparen,
         ];
-        let __rustylr_tset6: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::rbracket
+        static __RUSTYLR_TSET6: [GrammarTerminalClasses; 1usize] = [
+            GrammarTerminalClasses::rbracket,
         ];
-        let __rustylr_tset20: Vec<GrammarTerminalClasses> = vec![
-            GrammarTerminalClasses::eof
+        static __RUSTYLR_TSET20: [GrammarTerminalClasses; 1usize] = [
+            GrammarTerminalClasses::eof,
         ];
         let states: Vec<
             ::rusty_lr_core::parser::state::IntermediateState<
@@ -7461,14 +7533,13 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(175, true)),
             (GrammarNonTerminals::_GrammarLinePlus31,
             ::rusty_lr_core::parser::state::ShiftTarget::new(175, false)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 41,
-            42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
-            61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 149, 150,
-            151,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            Default::default(), ruleset : { static __RULES : [u8; 41usize] = [0, 41, 42,
+            43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+            62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 149, 150,
+            151,]; static __SHIFTED : [u8; 41usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted)
+            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::parengroup,
@@ -7476,27 +7547,27 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::RuleType,
             ::rusty_lr_core::parser::state::ShiftTarget::new(3, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![2]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![2]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [0, 1, 2,]; let shifted : & 'static [u8] = &
-            [1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            static __RULES : [u8; 3usize] = [0, 1, 2,]; static __SHIFTED : [u8; 3usize] =
+            [1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) |
+            { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![1]; __reduce_map
-            .extend(__rustylr_tset0.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [1,]; let shifted : & 'static [u8] = & [1,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef
-            { rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [1,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::colon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(4, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [0,]; let shifted : & 'static [u8]
-            = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [2,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7527,23 +7598,23 @@ impl GrammarParser {
             (GrammarNonTerminals::_TokenMappedStar16,
             ::rusty_lr_core::parser::state::ShiftTarget::new(72, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![81]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term,
+            vec![81]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [0, 3, 4, 5, 11, 12, 19, 20, 21, 22, 23, 24,
-            25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 78, 79, 80, 81,]; let shifted
-            : & 'static [u8] = & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (&
-            rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 28usize] = [0, 3, 4, 5, 11, 12, 19, 20, 21, 22, 23, 24,
+            25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 78, 79, 80, 81,]; static
+            __SHIFTED : [u8; 28usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule :
+            rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::equal,
             ::rusty_lr_core::parser::state::ShiftTarget::new(6, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![21]; __reduce_map
-            .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [12, 21,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [12, 21,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7562,48 +7633,45 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSet,
             ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)),
             (GrammarNonTerminals::Pattern,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(63, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [12, 19,
-            20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,]; let
-            shifted : & 'static [u8] = & [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(63, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 19usize] = [12, 19, 20,
+            21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,]; static
+            __SHIFTED : [u8; 19usize] = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![21];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [21,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [21,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![20];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [20,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [20,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(10, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [32, 33, 34, 35, 36,]; let shifted
-            : & 'static [u8] = & [1, 1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(|
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED :
+            [u8; 5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
             (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
             as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::lparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(11, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [32, 33, 34, 35, 36,]; let shifted
-            : & 'static [u8] = & [2, 2, 2, 2, 2,]; rules.iter().zip(shifted.iter()).map(|
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 5usize] = [32, 33, 34, 35, 36,]; static __SHIFTED :
+            [u8; 5usize] = [2, 2, 2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
             (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
             as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7622,21 +7690,20 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSet,
             ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)),
             (GrammarNonTerminals::Pattern,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(31, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [19, 20,
-            21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35,
-            36, 36,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,]; rules.iter().zip(shifted.iter()).map(|
+            ::rusty_lr_core::parser::state::ShiftTarget::new(31, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 23usize] = [19, 20, 21,
+            22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36,
+            36,]; static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
             (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
             as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![30];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [30,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [30,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7665,33 +7732,33 @@ impl GrammarParser {
             (GrammarNonTerminals::__PatternStar23SepPlus24,
             ::rusty_lr_core::parser::state::ShiftTarget::new(47, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![95]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term,
+            vec![95]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28,
-            29, 29, 30, 31, 32, 33, 34, 35, 36, 92, 93, 94, 95, 96, 97,]; let shifted : &
-            'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 26usize] = [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28,
+            29, 29, 30, 31, 32, 33, 34, 35, 36, 92, 93, 94, 95, 96, 97,]; static
+            __SHIFTED : [u8; 26usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (&
+            rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::caret,
             ::rusty_lr_core::parser::state::ShiftTarget::new(15, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_caretQuestion19,
             ::rusty_lr_core::parser::state::ShiftTarget::new(16, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![87]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term,
+            vec![87]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [19, 86, 87,]; let shifted : & 'static [u8] =
-            & [1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            static __RULES : [u8; 3usize] = [19, 86, 87,]; static __SHIFTED : [u8;
+            3usize] = [1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
+            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![86];
-            __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [86,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [86,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7706,11 +7773,11 @@ impl GrammarParser {
             (GrammarNonTerminals::_TerminalSetItemStar21,
             ::rusty_lr_core::parser::state::ShiftTarget::new(28, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![91]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term,
+            vec![91]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [13, 14, 15, 16, 17, 18, 19, 88, 89, 90, 91,];
-            let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 11usize] = [13, 14, 15, 16, 17, 18, 19, 88, 89, 90,
+            91,]; static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7718,10 +7785,10 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(18, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![13]; __reduce_map
-            .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [13, 14, 15,]; let shifted : & 'static [u8] = & [1, 1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            3usize] = [13, 14, 15,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7729,28 +7796,27 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(19, true)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(20, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [14, 15,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [14, 15,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![14];
-            __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [14,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![15];
-            __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [15,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7758,10 +7824,10 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(22, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![16]; __reduce_map
-            .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [16, 17, 18,]; let shifted : & 'static [u8] = & [1, 1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            3usize] = [16, 17, 18,]; static __SHIFTED : [u8; 3usize] = [1, 1, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7769,37 +7835,36 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(23, true)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(24, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [17, 18,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [17, 18,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![17];
-            __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [17,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [17,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![18];
-            __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [18,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [18,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![88];
-            __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [88,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [88,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7810,46 +7875,46 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSetItem,
             ::rusty_lr_core::parser::state::ShiftTarget::new(27, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [13, 14, 15, 16, 17, 18, 89, 90,]; let shifted
-            : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 1, 1,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef
-            { rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 8usize] = [13, 14, 15, 16, 17, 18, 89, 90,]; static
+            __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![89];
-            __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [89,]; let shifted : & 'static [u8] = & [2,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [89,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::rbracket,
             ::rusty_lr_core::parser::state::ShiftTarget::new(29, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [19,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![19];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [19,]; let shifted : & 'static [u8] = & [4,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [19,]; static __SHIFTED : [u8; 1usize] = [4,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![26];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [26,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [26,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7867,38 +7932,37 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),
             (GrammarTerminalClasses::comma,
             ::rusty_lr_core::parser::state::ShiftTarget::new(40, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [22, 23, 24, 25, 27, 31, 32, 33,
-            34, 35, 36,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, 1, 1, 4, 4, 4, 4,
-            4,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 11usize] = [22, 23, 24, 25, 27, 31, 32, 33, 34, 35,
+            36,]; static __SHIFTED : [u8; 11usize] = [1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![22];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [22,]; let shifted : & 'static [u8] = & [2,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [22,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![23];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [23,]; let shifted : & 'static [u8] = & [2,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [23,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![24];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [24,]; let shifted : & 'static [u8] = & [2,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [24,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7917,12 +7981,11 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSet,
             ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)),
             (GrammarNonTerminals::Pattern,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(36, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [19, 20,
-            21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 31, 32, 33, 34, 35, 36,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(36, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 19usize] = [19, 20, 21,
+            22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 31, 32, 33, 34, 35, 36,]; static
+            __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7938,19 +8001,19 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![31]; __reduce_map
-            .extend(__rustylr_tset7.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [22, 23, 24, 25, 27, 31,]; let shifted : & 'static [u8] = & [1, 1, 1, 1,
-            1, 3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            .extend(__RUSTYLR_TSET7.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            6usize] = [22, 23, 24, 25, 27, 31,]; static __SHIFTED : [u8; 6usize] = [1, 1,
+            1, 1, 1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted)
+            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![25];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [25,]; let shifted : & 'static [u8] = & [2,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [25,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7969,12 +8032,11 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSet,
             ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)),
             (GrammarNonTerminals::Pattern,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(39, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [19, 20,
-            21, 22, 23, 24, 25, 26, 27, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(39, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 19usize] = [19, 20, 21,
+            22, 23, 24, 25, 26, 27, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,]; static
+            __SHIFTED : [u8; 19usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -7988,10 +8050,10 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(37, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![27]; __reduce_map
-            .extend(__rustylr_tset8.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [22, 23, 24, 25, 27,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, 3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET8.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            5usize] = [22, 23, 24, 25, 27,]; static __SHIFTED : [u8; 5usize] = [1, 1, 1,
+            1, 3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8010,30 +8072,28 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::TerminalSet,
             ::rusty_lr_core::parser::state::ShiftTarget::new(30, true)),
             (GrammarNonTerminals::Pattern,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(51, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [19, 20,
-            21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35,
-            36, 36,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5,]; rules.iter().zip(shifted.iter()).map(|
+            ::rusty_lr_core::parser::state::ShiftTarget::new(51, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 23usize] = [19, 20, 21,
+            22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36,
+            36,]; static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
             (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
             as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::rparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(42, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [29,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![29];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [29,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [29,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8051,12 +8111,12 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![92]; __reduce_map
-            .extend(__rustylr_tset9.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [22, 23, 24, 25, 27, 31, 92,]; let shifted : & 'static [u8] = & [1, 1, 1,
-            1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            7usize] = [22, 23, 24, 25, 27, 31, 92,]; static __SHIFTED : [u8; 7usize] =
+            [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
+            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)),
@@ -8075,12 +8135,12 @@ impl GrammarParser {
             (GrammarNonTerminals::Pattern,
             ::rusty_lr_core::parser::state::ShiftTarget::new(45, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![94]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term,
+            vec![94]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
-            30, 31, 32, 33, 34, 35, 36, 93, 94,]; let shifted : & 'static [u8] = & [0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 20usize] = [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+            30, 31, 32, 33, 34, 35, 36, 93, 94,]; static __SHIFTED : [u8; 20usize] = [0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8098,19 +8158,19 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![93]; __reduce_map
-            .extend(__rustylr_tset9.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [22, 23, 24, 25, 27, 31, 93,]; let shifted : & 'static [u8] = & [1, 1, 1,
-            1, 1, 1, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET9.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            7usize] = [22, 23, 24, 25, 27, 31, 93,]; static __SHIFTED : [u8; 7usize] =
+            [1, 1, 1, 1, 1, 1, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
+            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![96];
-            __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [96,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [96,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8118,11 +8178,10 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(48, true)),
             (GrammarTerminalClasses::rparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(50, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [28, 97,]; let shifted : & 'static
-            [u8] = & [2, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [28, 97,]; static __SHIFTED : [u8; 2usize] =
+            [2, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::ident,
@@ -8146,30 +8205,30 @@ impl GrammarParser {
             (GrammarNonTerminals::_PatternStar23,
             ::rusty_lr_core::parser::state::ShiftTarget::new(49, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![95]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term,
+            vec![95]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
-            30, 31, 32, 33, 34, 35, 36, 92, 93, 94, 95, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 23usize] = [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+            30, 31, 32, 33, 34, 35, 36, 92, 93, 94, 95, 97,]; static __SHIFTED : [u8;
+            23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![97];
-            __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [97,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [97,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![28];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [28,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [28,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8192,11 +8251,11 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_commaQuestion25,
             ::rusty_lr_core::parser::state::ShiftTarget::new(61, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![99]; __reduce_map.extend(__rustylr_tset10.iter().map(| term | (* term,
+            vec![99]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [22, 23, 24, 25, 27, 31, 32, 33, 34, 35, 36,
-            98, 99,]; let shifted : & 'static [u8] = & [1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6,
-            0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 13usize] = [22, 23, 24, 25, 27, 31, 32, 33, 34, 35, 36,
+            98, 99,]; static __SHIFTED : [u8; 13usize] = [1, 1, 1, 1, 1, 1, 6, 6, 6, 6,
+            6, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8208,100 +8267,95 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(57, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![98]; __reduce_map
-            .extend(__rustylr_tset10.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [33, 34, 36, 98,]; let shifted : & 'static [u8] = & [7, 7,
-            7, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET10.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 4usize] = [33, 34, 36, 98,]; static __SHIFTED : [u8; 4usize] = [7, 7,
+            7, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::rparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(54, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [33,]; let shifted : & 'static
-            [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] =
+            [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![33];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [33,]; let shifted : & 'static [u8] = & [9,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::rparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(56, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [34,]; let shifted : & 'static
-            [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] =
+            [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![34];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [34,]; let shifted : & 'static [u8] = & [9,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::rparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(58, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [36,]; let shifted : & 'static
-            [u8] = & [8,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] =
+            [8,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![36];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [36,]; let shifted : & 'static [u8] = & [9,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [36,]; static __SHIFTED : [u8; 1usize] = [9,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::rparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(60, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [35,]; let shifted : & 'static
-            [u8] = & [7,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] =
+            [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![35];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [35,]; let shifted : & 'static [u8] = & [8,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::rparen,
             ::rusty_lr_core::parser::state::ShiftTarget::new(62, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [32,]; let shifted : & 'static
-            [u8] = & [7,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] =
+            [7,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![32];
-            __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [32,]; let shifted : & 'static [u8] = & [8,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [32,]; static __SHIFTED : [u8; 1usize] = [8,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8319,30 +8373,29 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![12]; __reduce_map
-            .extend(__rustylr_tset11.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [12, 22, 23, 24, 25, 27, 31,]; let shifted : & 'static [u8]
-            = & [3, 1, 1, 1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 7usize] = [12, 22, 23, 24, 25, 27, 31,]; static __SHIFTED : [u8;
+            7usize] = [3, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(65, false)),
             (GrammarTerminalClasses::pipe,
             ::rusty_lr_core::parser::state::ShiftTarget::new(66, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [0, 3,]; let shifted : & 'static
-            [u8] = & [4, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [0, 3,]; static __SHIFTED : [u8; 2usize] =
+            [4, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![0]; __reduce_map
-            .extend(__rustylr_tset12.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [0,]; let shifted : & 'static [u8] = & [5,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET12.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8371,30 +8424,30 @@ impl GrammarParser {
             (GrammarNonTerminals::_TokenMappedStar16,
             ::rusty_lr_core::parser::state::ShiftTarget::new(72, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![81]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term,
+            vec![81]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [3, 5, 11, 12, 19, 20, 21, 22, 23, 24, 25, 26,
-            27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 78, 79, 80, 81,]; let shifted : &
-            'static [u8] = & [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 26usize] = [3, 5, 11, 12, 19, 20, 21, 22, 23, 24, 25,
+            26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 78, 79, 80, 81,]; static
+            __SHIFTED : [u8; 26usize] = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (&
+            rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![3]; __reduce_map
-            .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [3,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![78];
-            __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [78,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [78,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8412,12 +8465,12 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(38, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![11]; __reduce_map
-            .extend(__rustylr_tset11.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [11, 22, 23, 24, 25, 27, 31,]; let shifted : & 'static [u8]
-            = & [1, 1, 1, 1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET11.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 7usize] = [11, 22, 23, 24, 25, 27, 31,]; static __SHIFTED : [u8;
+            7usize] = [1, 1, 1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)),
@@ -8438,21 +8491,21 @@ impl GrammarParser {
             (GrammarNonTerminals::Pattern,
             ::rusty_lr_core::parser::state::ShiftTarget::new(69, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![80]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term,
+            vec![80]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27,
-            28, 29, 30, 31, 32, 33, 34, 35, 36, 79, 80,]; let shifted : & 'static [u8] =
-            & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 22usize] = [11, 12, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+            28, 29, 30, 31, 32, 33, 34, 35, 36, 79, 80,]; static __SHIFTED : [u8;
+            22usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+            1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![79];
-            __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [79,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [79,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8465,11 +8518,11 @@ impl GrammarParser {
             (GrammarNonTerminals::_PrecDefStar18,
             ::rusty_lr_core::parser::state::ShiftTarget::new(86, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![85]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term,
+            vec![85]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [5, 6, 7, 8, 9, 10, 82, 83, 84, 85,]; let
-            shifted : & 'static [u8] = & [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 10usize] = [5, 6, 7, 8, 9, 10, 82, 83, 84, 85,]; static
+            __SHIFTED : [u8; 10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8479,10 +8532,9 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(79, true)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(82, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [6, 7, 8, 9, 10,]; let shifted : &
-            'static [u8] = & [1, 1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (&
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 5usize] = [6, 7, 8, 9, 10,]; static __SHIFTED : [u8;
+            5usize] = [1, 1, 1, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (&
             rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as
             usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8493,90 +8545,92 @@ impl GrammarParser {
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(77, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(78, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [6, 7,
-            39, 40,]; let shifted : & 'static [u8] = & [2, 2, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(78, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [6, 7, 39,
+            40,]; static __SHIFTED : [u8; 4usize] = [2, 2, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![39];
-            __reduce_map.extend(__rustylr_tset15.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [39,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [39,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![40];
-            __reduce_map.extend(__rustylr_tset15.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET15.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [40,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [40,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![7]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [7,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef
-            { rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [6,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef
-            { rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [6,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::literal,
             ::rusty_lr_core::parser::state::ShiftTarget::new(80, true)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(81, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [8, 9,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [8, 9,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![8]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [8,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef
-            { rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [8,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![9]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [9,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef
-            { rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![10];
-            __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [10,]; let shifted : & 'static [u8] = & [2,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![82];
-            __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [82,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [82,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8585,19 +8639,19 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::PrecDef,
             ::rusty_lr_core::parser::state::ShiftTarget::new(85, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![84]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term,
+            vec![84]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [6, 7, 8, 9, 10, 83, 84,]; let shifted : &
-            'static [u8] = & [0, 0, 0, 0, 0, 1, 1,]; rules.iter().zip(shifted.iter())
+            static __RULES : [u8; 7usize] = [6, 7, 8, 9, 10, 83, 84,]; static __SHIFTED :
+            [u8; 7usize] = [0, 0, 0, 0, 0, 1, 1,]; __RULES.iter().zip(__SHIFTED.iter())
             .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule :
             rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![83];
-            __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [83,]; let shifted : & 'static [u8] = & [2,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [83,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8606,37 +8660,37 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::Action,
             ::rusty_lr_core::parser::state::ShiftTarget::new(88, true)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![38]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term,
+            vec![38]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [5, 37, 38,]; let shifted : & 'static [u8] = &
-            [2, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            static __RULES : [u8; 3usize] = [5, 37, 38,]; static __SHIFTED : [u8; 3usize]
+            = [2, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted)
+            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![37];
-            __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [37,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![5]; __reduce_map
-            .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [5,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![4]; __reduce_map
-            .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [4,]; let shifted : & 'static [u8] = & [1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8674,13 +8728,12 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(166, true)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(170, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [41, 42, 43, 44, 45, 46, 47, 48,
-            49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
-            68, 69, 70, 71, 72, 73, 74,]; let shifted : & 'static [u8] = & [1, 1, 1, 1,
-            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-            1, 1, 1, 1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 34usize] = [41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+            71, 72, 73, 74,]; static __SHIFTED : [u8; 34usize] = [1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8693,38 +8746,36 @@ impl GrammarParser {
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral,
             ::rusty_lr_core::parser::state::ShiftTarget::new(94, true)),
             (GrammarNonTerminals::_IdentOrLiteralPlus28,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(95, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [39, 40,
-            50, 51, 143, 144,]; let shifted : & 'static [u8] = & [0, 0, 2, 2, 0, 0,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(95, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 6usize] = [39, 40, 50,
+            51, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(93, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [51,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![51];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [51,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [51,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![143];
-            __reduce_map.extend(__rustylr_tset16.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [143,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [143,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8735,29 +8786,28 @@ impl GrammarParser {
             (GrammarTerminalClasses::literal,
             ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [39, 40,
-            50, 144,]; let shifted : & 'static [u8] = & [0, 0, 3, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [39, 40, 50,
+            144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![50];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [50,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [50,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![144];
-            __reduce_map.extend(__rustylr_tset16.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [144,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [144,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8771,28 +8821,26 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(94, true)),
             (GrammarNonTerminals::_IdentOrLiteralPlus28,
             ::rusty_lr_core::parser::state::ShiftTarget::new(101, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [39, 40,
-            52, 53, 143, 144,]; let shifted : & 'static [u8] = & [0, 0, 2, 2, 0, 0,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 6usize] = [39, 40, 52,
+            53, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(100, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [53,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![53];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [53,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8803,20 +8851,19 @@ impl GrammarParser {
             (GrammarTerminalClasses::literal,
             ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [39, 40,
-            52, 144,]; let shifted : & 'static [u8] = & [0, 0, 3, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [39, 40, 52,
+            144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![52];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [52,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [52,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -8824,11 +8871,10 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(104, true)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(110, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [41, 42, 43,]; let shifted : &
-            'static [u8] = & [2, 2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule,
-            & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 3usize] = [41, 42, 43,]; static __SHIFTED : [u8;
+            3usize] = [2, 2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
+            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
             shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::ident,
@@ -8919,32 +8965,31 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
             (GrammarNonTerminals::__TermSet26Plus27,
             ::rusty_lr_core::parser::state::ShiftTarget::new(107, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [41, 42,
+            Default::default(), ruleset : { static __RULES : [u8; 45usize] = [41, 42,
             100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
             115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; let
-            shifted : & 'static [u8] = & [3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static
+            __SHIFTED : [u8; 45usize] = [3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![42];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [42,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![141];
-            __reduce_map.extend(__rustylr_tset17.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET17.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [141,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [141,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9034,50 +9079,48 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26,
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [41,
-            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-            115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; let shifted : &
-            'static [u8] = & [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 43usize] = [41, 100,
+            101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+            131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; static __SHIFTED :
+            [u8; 43usize] = [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![41];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [41,]; let shifted : & 'static [u8] = & [5,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [41,]; static __SHIFTED : [u8; 1usize] =
+            [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![142];
-            __reduce_map.extend(__rustylr_tset17.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET17.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [142,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [142,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(111, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [43,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![43];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [43,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [43,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9085,46 +9128,43 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(113, true)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(115, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [44, 45,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [44, 45,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(114, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [44,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![44];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [44,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(116, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![45];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [45,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9216,23 +9256,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
             (GrammarNonTerminals::__TermSet26Plus27,
             ::rusty_lr_core::parser::state::ShiftTarget::new(119, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [46, 47,
+            Default::default(), ruleset : { static __RULES : [u8; 45usize] = [46, 47,
             100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
             115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; let
-            shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static
+            __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![47];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [47,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9322,23 +9361,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26,
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [46,
-            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-            115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; let shifted : &
-            'static [u8] = & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 43usize] = [46, 100,
+            101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+            131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; static __SHIFTED :
+            [u8; 43usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![46];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [46,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9430,23 +9468,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
             (GrammarNonTerminals::__TermSet26Plus27,
             ::rusty_lr_core::parser::state::ShiftTarget::new(123, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [48, 49,
+            Default::default(), ruleset : { static __RULES : [u8; 45usize] = [48, 49,
             100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
             115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; let
-            shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static
+            __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![49];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [49,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9536,23 +9573,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26,
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [48,
-            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-            115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; let shifted : &
-            'static [u8] = & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 43usize] = [48, 100,
+            101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+            131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; static __SHIFTED :
+            [u8; 43usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![48];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [48,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [48,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9644,23 +9680,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
             (GrammarNonTerminals::__TermSet26Plus27,
             ::rusty_lr_core::parser::state::ShiftTarget::new(127, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [56, 57,
+            Default::default(), ruleset : { static __RULES : [u8; 45usize] = [56, 57,
             100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
             115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; let
-            shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static
+            __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![57];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [57,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [57,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9750,23 +9785,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26,
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [56,
-            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-            115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; let shifted : &
-            'static [u8] = & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 43usize] = [56, 100,
+            101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+            131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; static __SHIFTED :
+            [u8; 43usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![56];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [56,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [56,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9858,23 +9892,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
             (GrammarNonTerminals::__TermSet26Plus27,
             ::rusty_lr_core::parser::state::ShiftTarget::new(131, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [58, 59,
+            Default::default(), ruleset : { static __RULES : [u8; 45usize] = [58, 59,
             100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
             115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; let
-            shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static
+            __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![59];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [59,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [59,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9964,23 +9997,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26,
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [58,
-            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-            115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; let shifted : &
-            'static [u8] = & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 43usize] = [58, 100,
+            101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+            131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; static __SHIFTED :
+            [u8; 43usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![58];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [58,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [58,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -9988,37 +10020,35 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(134, false)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(135, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [62, 63,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [62, 63,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![62];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [62,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [62,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(136, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [63,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![63];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [63,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [63,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10026,37 +10056,35 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(138, false)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(139, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [60, 61,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [60, 61,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![60];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [60,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [60,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(140, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [61,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![61];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [61,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [61,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10070,28 +10098,26 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(94, true)),
             (GrammarNonTerminals::_IdentOrLiteralPlus28,
             ::rusty_lr_core::parser::state::ShiftTarget::new(144, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [39, 40,
-            54, 55, 143, 144,]; let shifted : & 'static [u8] = & [0, 0, 2, 2, 0, 0,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 6usize] = [39, 40, 54,
+            55, 143, 144,]; static __SHIFTED : [u8; 6usize] = [0, 0, 2, 2, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(143, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [55,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![55];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [55,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [55,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10102,20 +10128,19 @@ impl GrammarParser {
             (GrammarTerminalClasses::literal,
             ::rusty_lr_core::parser::state::ShiftTarget::new(76, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::IdentOrLiteral,
-            ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [39, 40,
-            54, 144,]; let shifted : & 'static [u8] = & [0, 0, 3, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::parser::state::ShiftTarget::new(97, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [39, 40, 54,
+            144,]; static __SHIFTED : [u8; 4usize] = [0, 0, 3, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![54];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [54,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [54,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10123,37 +10148,35 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(147, false)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(148, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [64, 65,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [64, 65,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![64];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [64,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [64,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(149, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [65,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![65];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [65,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [65,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10161,37 +10184,35 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(151, false)),
             (GrammarTerminalClasses::error,
             ::rusty_lr_core::parser::state::ShiftTarget::new(152, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [66, 67,]; let shifted : & 'static
-            [u8] = & [2, 2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted)
-            | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 2usize] = [66, 67,]; static __SHIFTED : [u8; 2usize] =
+            [2, 2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![66];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [66,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [66,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(153, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [67,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![67];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [67,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [67,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10204,37 +10225,36 @@ impl GrammarParser {
             (GrammarNonTerminals::_identStar30,
             ::rusty_lr_core::parser::state::ShiftTarget::new(160, true)),], reduce_map :
             { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules
-            = vec![148]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (*
+            = vec![148]; __reduce_map.extend(__RUSTYLR_TSET18.iter().map(| term | (*
             term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset
-            : { let rules : & 'static [u8] = & [68, 69, 145, 146, 147, 148,]; let shifted
-            : & 'static [u8] = & [2, 2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter())
-            .map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule :
-            rule as usize, shifted : shifted as usize, } }).collect() } },
+            : { static __RULES : [u8; 6usize] = [68, 69, 145, 146, 147, 148,]; static
+            __SHIFTED : [u8; 6usize] = [2, 2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED
+            .iter()).map(| (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef
+            { rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![145];
-            __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [145,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [145,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(157, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [69,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![69];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [69,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [69,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10242,37 +10262,36 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(159, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![147]; __reduce_map
-            .extend(__rustylr_tset18.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [146, 147,]; let shifted : & 'static [u8] = & [1, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET18.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 2usize] = [146, 147,]; static __SHIFTED : [u8; 2usize] = [1, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![146];
-            __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [146,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [146,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(161, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [68,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![68];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [68,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [68,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10364,23 +10383,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
             (GrammarNonTerminals::__TermSet26Plus27,
             ::rusty_lr_core::parser::state::ShiftTarget::new(164, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [70, 71,
+            Default::default(), ruleset : { static __RULES : [u8; 45usize] = [70, 71,
             100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
             115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; let
-            shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static
+            __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![71];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [71,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [71,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10470,23 +10488,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26,
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [70,
-            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-            115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; let shifted : &
-            'static [u8] = & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 43usize] = [70, 100,
+            101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+            131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; static __SHIFTED :
+            [u8; 43usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![70];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [70,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [70,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10578,23 +10595,22 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
             (GrammarNonTerminals::__TermSet26Plus27,
             ::rusty_lr_core::parser::state::ShiftTarget::new(168, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [72, 73,
+            Default::default(), ruleset : { static __RULES : [u8; 45usize] = [72, 73,
             100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
             115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; let
-            shifted : & 'static [u8] = & [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,]; static
+            __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![73];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [73,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [73,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10684,50 +10700,48 @@ impl GrammarParser {
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),],
             shift_goto_map_nonterm : vec![(GrammarNonTerminals::_TermSet26,
             ::rusty_lr_core::parser::state::ShiftTarget::new(109, true)),], reduce_map :
-            { let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [72,
-            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-            115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
-            130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; let shifted : &
-            'static [u8] = & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            Default::default(), ruleset : { static __RULES : [u8; 43usize] = [72, 100,
+            101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+            116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
+            131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142,]; static __SHIFTED :
+            [u8; 43usize] = [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![72];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [72,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [72,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::semicolon,
             ::rusty_lr_core::parser::state::ShiftTarget::new(171, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [74,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![74];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [74,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [74,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![75];
-            __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [75,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [75,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
@@ -10744,41 +10758,39 @@ impl GrammarParser {
             (GrammarNonTerminals::_GrammarLinePlus31,
             ::rusty_lr_core::parser::state::ShiftTarget::new(174, true)),], reduce_map :
             { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules
-            = vec![149]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (*
+            = vec![149]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (*
             term, reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset
-            : { let rules : & 'static [u8] = & [0, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+            : { static __RULES : [u8; 41usize] = [0, 41, 42, 43, 44, 45, 46, 47, 48, 49,
             50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
-            69, 70, 71, 72, 73, 74, 75, 76, 149, 149, 150, 150,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            69, 70, 71, 72, 73, 74, 75, 76, 149, 149, 150, 150,]; static __SHIFTED : [u8;
+            41usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
             = std::collections::BTreeMap::new(); let reduce_rules = vec![150];
-            __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term,
+            __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [150,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [150,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
             vec![(GrammarTerminalClasses::eof,
             ::rusty_lr_core::parser::state::ShiftTarget::new(176, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [151,]; let shifted : & 'static
-            [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
             shifted as usize, } }).collect() } },
             ::rusty_lr_core::parser::state::IntermediateState { shift_goto_map_term :
-            vec![], shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map
-            = std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [151,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            vec![], shift_goto_map_nonterm : vec![], reduce_map : Default::default(),
+            ruleset : { static __RULES : [u8; 1usize] = [151,]; static __SHIFTED : [u8;
+            1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
+            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
         ];
         let states: Vec<GrammarState> = states
             .into_iter()
diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs
index a2fd1f72..a50d2cd2 100644
--- a/scripts/diff/calculator.rs
+++ b/scripts/diff/calculator.rs
@@ -685,15 +685,20 @@ impl EParser {
             vec![::rusty_lr::Token::NonTerm(ENonTerminals::E),
             ::rusty_lr::Token::Term(ETerminalClasses::eof),], precedence : None, },
         ];
-        let __rustylr_tset0: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::plus, ETerminalClasses::star, ETerminalClasses::rparen,
-            ETerminalClasses::eof
+        static __RUSTYLR_TSET0: [ETerminalClasses; 4usize] = [
+            ETerminalClasses::plus,
+            ETerminalClasses::star,
+            ETerminalClasses::rparen,
+            ETerminalClasses::eof,
         ];
-        let __rustylr_tset2: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::plus, ETerminalClasses::rparen, ETerminalClasses::eof
+        static __RUSTYLR_TSET2: [ETerminalClasses; 3usize] = [
+            ETerminalClasses::plus,
+            ETerminalClasses::rparen,
+            ETerminalClasses::eof,
         ];
-        let __rustylr_tset1: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::rparen, ETerminalClasses::eof
+        static __RUSTYLR_TSET1: [ETerminalClasses; 2usize] = [
+            ETerminalClasses::rparen,
+            ETerminalClasses::eof,
         ];
         let states: Vec<
             ::rusty_lr::parser::state::IntermediateState<
@@ -711,19 +716,18 @@ impl EParser {
             ::rusty_lr::parser::state::ShiftTarget::new(3, true)), (ENonTerminals::M,
             ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P,
             ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::E,
-            ::rusty_lr::parser::state::ShiftTarget::new(11, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 1,
-            2, 3, 4, 5, 6, 7,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0,
-            0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(11, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 8usize] = [0, 1, 2, 3,
+            4, 5, 6, 7,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![4]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![4]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [4,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::num,
@@ -733,21 +737,20 @@ impl EParser {
             ::rusty_lr::parser::state::ShiftTarget::new(3, true)), (ENonTerminals::M,
             ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P,
             ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::E,
-            ::rusty_lr::parser::state::ShiftTarget::new(9, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 1,
-            2, 3, 4, 5, 5, 6,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 1,
-            0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(9, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 8usize] = [0, 1, 2, 3,
+            4, 5, 5, 6,]; static __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 1, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::plus,
             ::rusty_lr::parser::state::ShiftTarget::new(4, true)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [0, 6,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [0, 6,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::num,
@@ -756,29 +759,28 @@ impl EParser {
             false)),], shift_goto_map_nonterm : vec![(ENonTerminals::A,
             ::rusty_lr::parser::state::ShiftTarget::new(5, true)), (ENonTerminals::M,
             ::rusty_lr::parser::state::ShiftTarget::new(6, true)), (ENonTerminals::P,
-            ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [0, 0,
-            1, 2, 3, 4, 5,]; let shifted : & 'static [u8] = & [0, 2, 0, 0, 0, 0, 0,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(6, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 7usize] = [0, 0, 1, 2,
+            3, 4, 5,]; static __SHIFTED : [u8; 7usize] = [0, 2, 0, 0, 0, 0, 0,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![0]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![0]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [0,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [3,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::star,
             ::rusty_lr::parser::state::ShiftTarget::new(7, false)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![1]; __reduce_map
-            .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [1, 2,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [1, 2,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::num,
@@ -786,49 +788,45 @@ impl EParser {
             (ETerminalClasses::lparen, ::rusty_lr::parser::state::ShiftTarget::new(2,
             false)),], shift_goto_map_nonterm : vec![(ENonTerminals::M,
             ::rusty_lr::parser::state::ShiftTarget::new(8, true)), (ENonTerminals::P,
-            ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [2, 2,
-            3, 4, 5,]; let shifted : & 'static [u8] = & [0, 2, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [2, 2, 3, 4,
+            5,]; static __SHIFTED : [u8; 5usize] = [0, 2, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![2]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![2]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [2,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = [3,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::rparen,
             ::rusty_lr::parser::state::ShiftTarget::new(10, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [5,]; let shifted : & 'static [u8]
-            = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [2,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![5]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![5]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [5,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [5,]; static __SHIFTED : [u8; 1usize] = [3,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::eof,
             ::rusty_lr::parser::state::ShiftTarget::new(12, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [7,]; let shifted : & 'static [u8]
-            = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [7,]; static __SHIFTED : [u8; 1usize] = [1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
-            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [7,];
-            let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(|
+            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 1usize] = [7,]; static
+            __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
             (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
             usize, shifted : shifted as usize, } }).collect() } },
         ];
diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs
index c6d47155..36d6ae93 100644
--- a/scripts/diff/calculator_u8.rs
+++ b/scripts/diff/calculator_u8.rs
@@ -950,40 +950,57 @@ impl EParser {
             vec![::rusty_lr::Token::NonTerm(ENonTerminals::E),
             ::rusty_lr::Token::Term(ETerminalClasses::eof),], precedence : None, },
         ];
-        let __rustylr_tset4: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::TermClass0, ETerminalClasses::TermClass2,
-            ETerminalClasses::TermClass3, ETerminalClasses::TermClass4,
-            ETerminalClasses::TermClass5, ETerminalClasses::TermClass6,
-            ETerminalClasses::TermClass7, ETerminalClasses::TermClass8,
-            ETerminalClasses::eof
+        static __RUSTYLR_TSET4: [ETerminalClasses; 9usize] = [
+            ETerminalClasses::TermClass0,
+            ETerminalClasses::TermClass2,
+            ETerminalClasses::TermClass3,
+            ETerminalClasses::TermClass4,
+            ETerminalClasses::TermClass5,
+            ETerminalClasses::TermClass6,
+            ETerminalClasses::TermClass7,
+            ETerminalClasses::TermClass8,
+            ETerminalClasses::eof,
         ];
-        let __rustylr_tset6: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::TermClass0, ETerminalClasses::TermClass3,
-            ETerminalClasses::TermClass5, ETerminalClasses::TermClass6,
-            ETerminalClasses::TermClass7, ETerminalClasses::TermClass8,
-            ETerminalClasses::eof
+        static __RUSTYLR_TSET6: [ETerminalClasses; 7usize] = [
+            ETerminalClasses::TermClass0,
+            ETerminalClasses::TermClass3,
+            ETerminalClasses::TermClass5,
+            ETerminalClasses::TermClass6,
+            ETerminalClasses::TermClass7,
+            ETerminalClasses::TermClass8,
+            ETerminalClasses::eof,
         ];
-        let __rustylr_tset3: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::TermClass2, ETerminalClasses::TermClass3,
-            ETerminalClasses::TermClass4, ETerminalClasses::TermClass5,
-            ETerminalClasses::TermClass6, ETerminalClasses::TermClass7,
-            ETerminalClasses::TermClass8, ETerminalClasses::eof
+        static __RUSTYLR_TSET3: [ETerminalClasses; 8usize] = [
+            ETerminalClasses::TermClass2,
+            ETerminalClasses::TermClass3,
+            ETerminalClasses::TermClass4,
+            ETerminalClasses::TermClass5,
+            ETerminalClasses::TermClass6,
+            ETerminalClasses::TermClass7,
+            ETerminalClasses::TermClass8,
+            ETerminalClasses::eof,
         ];
-        let __rustylr_tset0: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::TermClass2, ETerminalClasses::TermClass4,
-            ETerminalClasses::TermClass5, ETerminalClasses::TermClass6
+        static __RUSTYLR_TSET0: [ETerminalClasses; 4usize] = [
+            ETerminalClasses::TermClass2,
+            ETerminalClasses::TermClass4,
+            ETerminalClasses::TermClass5,
+            ETerminalClasses::TermClass6,
         ];
-        let __rustylr_tset5: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::TermClass3, ETerminalClasses::TermClass7,
-            ETerminalClasses::TermClass8
+        static __RUSTYLR_TSET5: [ETerminalClasses; 3usize] = [
+            ETerminalClasses::TermClass3,
+            ETerminalClasses::TermClass7,
+            ETerminalClasses::TermClass8,
         ];
-        let __rustylr_tset1: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::TermClass3, ETerminalClasses::TermClass7,
-            ETerminalClasses::TermClass8, ETerminalClasses::eof
+        static __RUSTYLR_TSET1: [ETerminalClasses; 4usize] = [
+            ETerminalClasses::TermClass3,
+            ETerminalClasses::TermClass7,
+            ETerminalClasses::TermClass8,
+            ETerminalClasses::eof,
         ];
-        let __rustylr_tset2: Vec<ETerminalClasses> = vec![
-            ETerminalClasses::TermClass7, ETerminalClasses::TermClass8,
-            ETerminalClasses::eof
+        static __RUSTYLR_TSET2: [ETerminalClasses; 3usize] = [
+            ETerminalClasses::TermClass7,
+            ETerminalClasses::TermClass8,
+            ETerminalClasses::eof,
         ];
         let states: Vec<
             ::rusty_lr::parser::state::IntermediateState<
@@ -1005,19 +1022,19 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 11usize] = [2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16,];
+            static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![3]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term,
+            vec![3]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [3,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [3,]; static __SHIFTED : [u8; 1usize] = [1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::TermClass7,
@@ -1026,17 +1043,15 @@ impl EParser {
             true)), (ETerminalClasses::eof,
             ::rusty_lr::parser::state::ShiftTarget::new(3, true)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Op,
-            ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [5, 8,
-            9, 16,]; let shifted : & 'static [u8] = & [1, 0, 0, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [5, 8, 9,
+            16,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
-            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [16,];
-            let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(|
+            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 1usize] = [16,]; static
+            __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
             (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
             usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
@@ -1051,11 +1066,11 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 11usize] = [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,];
+            static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::TermClass7,
@@ -1064,28 +1079,29 @@ impl EParser {
             true)),], shift_goto_map_nonterm : vec![(ENonTerminals::Op,
             ::rusty_lr::parser::state::ShiftTarget::new(4, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![5]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![5]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [5, 5, 8, 9,]; let shifted : & 'static [u8] =
-            & [1, 3, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) |
-            { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted
-            as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
-            shift_goto_map_term : vec![(ETerminalClasses::TermClass0,
+            static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8;
+            4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule,
+            & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
+            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
+            vec![(ETerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(7, false)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![12]; __reduce_map
-            .extend(__rustylr_tset3.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [11, 12,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET3.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![11]; __reduce_map.extend(__rustylr_tset4.iter().map(| term | (* term,
+            vec![11]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [11,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [11,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::TermClass2,
@@ -1099,12 +1115,11 @@ impl EParser {
             shift_goto_map_nonterm : vec![(ENonTerminals::Digit,
             ::rusty_lr::parser::state::ShiftTarget::new(19, true)),
             (ENonTerminals::_DigitPlus9, ::rusty_lr::parser::state::ShiftTarget::new(20,
-            true)),], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [0, 1, 2, 4, 6, 14, 15,]; let
-            shifted : & 'static [u8] = & [0, 0, 1, 1, 1, 0, 0,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            true)),], reduce_map : Default::default(), ruleset : { static __RULES : [u8;
+            7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0,
+            1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
+            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
+            : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(ETerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(6, false)),],
@@ -1117,11 +1132,11 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(15, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 13,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 11usize] = [2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 13,];
+            static __SHIFTED : [u8; 11usize] = [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::TermClass3,
@@ -1131,11 +1146,10 @@ impl EParser {
             (ETerminalClasses::TermClass8,
             ::rusty_lr::parser::state::ShiftTarget::new(13, true)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Op,
-            ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [4, 5,
-            8, 9,]; let shifted : & 'static [u8] = & [3, 1, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [4, 5, 8,
+            9,]; static __SHIFTED : [u8; 4usize] = [3, 1, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::TermClass0,
@@ -1145,22 +1159,22 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(12, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [4, 10, 11, 12, 13,]; let shifted : & 'static
-            [u8] = & [4, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [4, 10, 11, 12, 13,]; static __SHIFTED : [u8;
+            5usize] = [4, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (&
+            rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![4]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [4,]; let shifted : & 'static [u8] = & [5,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(ETerminalClasses::TermClass0,
+            .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [4,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(ETerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(6, false)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Number,
             ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P,
@@ -1171,11 +1185,11 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(15, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 11usize] = [2, 3, 4, 5, 5, 6, 7, 10, 11, 12, 13,];
+            static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::TermClass7,
@@ -1185,13 +1199,14 @@ impl EParser {
             shift_goto_map_nonterm : vec![(ENonTerminals::Op,
             ::rusty_lr::parser::state::ShiftTarget::new(13, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![5]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term,
+            vec![5]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [5, 5, 8, 9,]; let shifted : & 'static [u8] =
-            & [1, 3, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) |
-            { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted
-            as usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
-            shift_goto_map_term : vec![(ETerminalClasses::TermClass2,
+            static __RULES : [u8; 4usize] = [5, 5, 8, 9,]; static __SHIFTED : [u8;
+            4usize] = [1, 3, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule,
+            & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
+            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
+            vec![(ETerminalClasses::TermClass2,
             ::rusty_lr::parser::state::ShiftTarget::new(9, false)),
             (ETerminalClasses::TermClass4,
             ::rusty_lr::parser::state::ShiftTarget::new(16, false)),
@@ -1202,12 +1217,11 @@ impl EParser {
             shift_goto_map_nonterm : vec![(ENonTerminals::Digit,
             ::rusty_lr::parser::state::ShiftTarget::new(19, true)),
             (ENonTerminals::_DigitPlus9, ::rusty_lr::parser::state::ShiftTarget::new(20,
-            true)),], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [0, 1, 2, 4, 6, 14, 15,]; let
-            shifted : & 'static [u8] = & [0, 0, 1, 1, 1, 0, 0,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
+            true)),], reduce_map : Default::default(), ruleset : { static __RULES : [u8;
+            7usize] = [0, 1, 2, 4, 6, 14, 15,]; static __SHIFTED : [u8; 7usize] = [0, 0,
+            1, 1, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
+            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
+            : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(ETerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(6, false)),],
@@ -1220,37 +1234,37 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(15, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 11usize] = [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,];
+            static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm :
             vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(13,
             true)),], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map
-            .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [5, 6,]; let shifted : & 'static [u8] = & [1, 3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = [1, 3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![0]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term,
+            vec![0]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [0,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [0,]; static __SHIFTED : [u8; 1usize] = [1,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![14]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term,
+            vec![14]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [14,]; let shifted : & 'static [u8] = & [1,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(ETerminalClasses::TermClass0,
@@ -1266,30 +1280,30 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(22, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset1.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [0, 1, 2, 10, 11, 12, 13, 15,]; let shifted :
-            & 'static [u8] = & [0, 0, 2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); let reduce_rules = vec![15]; __reduce_map
-            .extend(__rustylr_tset6.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [15,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); let reduce_rules = vec![2]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [2,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(ETerminalClasses::TermClass0,
+            static __RULES : [u8; 8usize] = [0, 1, 2, 10, 11, 12, 13, 15,]; static
+            __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
+            let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
+            vec![15]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            static __RULES : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
+            let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
+            vec![2]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            static __RULES : [u8; 1usize] = [2,]; static __SHIFTED : [u8; 1usize] = [3,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(ETerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(6, false)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Number,
             ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P,
@@ -1300,21 +1314,21 @@ impl EParser {
             (ENonTerminals::__Terminal32Star7,
             ::rusty_lr::parser::state::ShiftTarget::new(8, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![13]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![13]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,]; let
-            shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 11usize] = [2, 3, 4, 5, 6, 6, 7, 10, 11, 12, 13,];
+            static __SHIFTED : [u8; 11usize] = [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm :
             vec![(ENonTerminals::Op, ::rusty_lr::parser::state::ShiftTarget::new(4,
             true)),], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![6]; __reduce_map
-            .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [5, 6,]; let shifted : & 'static [u8] = & [1, 3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [5, 6,]; static __SHIFTED : [u8; 2usize] = [1, 3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } },
         ];
diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs
index d4c90287..d556b2c7 100644
--- a/scripts/diff/json.rs
+++ b/scripts/diff/json.rs
@@ -1799,136 +1799,205 @@ impl JsonParser {
             vec![::rusty_lr::Token::NonTerm(JsonNonTerminals::Json),
             ::rusty_lr::Token::Term(JsonTerminalClasses::eof),], precedence : None, },
         ];
-        let __rustylr_tset6: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13,
-            JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19,
-            JsonTerminalClasses::TermClass21
+        static __RUSTYLR_TSET6: [JsonTerminalClasses; 7usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass13,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::TermClass21,
         ];
-        let __rustylr_tset4: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13,
-            JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19,
-            JsonTerminalClasses::TermClass21, JsonTerminalClasses::TermClass28,
-            JsonTerminalClasses::eof
+        static __RUSTYLR_TSET4: [JsonTerminalClasses; 9usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass13,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::TermClass21,
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset14: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13,
-            JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19,
-            JsonTerminalClasses::TermClass28
+        static __RUSTYLR_TSET14: [JsonTerminalClasses; 7usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass13,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::TermClass28,
         ];
-        let __rustylr_tset11: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass16,
-            JsonTerminalClasses::TermClass21, JsonTerminalClasses::TermClass28,
-            JsonTerminalClasses::eof
+        static __RUSTYLR_TSET11: [JsonTerminalClasses; 7usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass16,
+            JsonTerminalClasses::TermClass21,
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset21: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass18,
-            JsonTerminalClasses::TermClass19, JsonTerminalClasses::TermClass21
+        static __RUSTYLR_TSET21: [JsonTerminalClasses; 6usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::TermClass21,
         ];
-        let __rustylr_tset17: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass18,
-            JsonTerminalClasses::TermClass19, JsonTerminalClasses::TermClass21,
-            JsonTerminalClasses::TermClass28, JsonTerminalClasses::eof
+        static __RUSTYLR_TSET17: [JsonTerminalClasses; 8usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::TermClass21,
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset16: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass18,
-            JsonTerminalClasses::TermClass19, JsonTerminalClasses::TermClass28
+        static __RUSTYLR_TSET16: [JsonTerminalClasses; 6usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::TermClass28,
         ];
-        let __rustylr_tset22: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21
+        static __RUSTYLR_TSET22: [JsonTerminalClasses; 4usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass21,
         ];
-        let __rustylr_tset2: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21,
-            JsonTerminalClasses::TermClass28, JsonTerminalClasses::eof
+        static __RUSTYLR_TSET2: [JsonTerminalClasses; 6usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass21,
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset18: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass28
+        static __RUSTYLR_TSET18: [JsonTerminalClasses; 4usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass28,
         ];
-        let __rustylr_tset3: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass13, JsonTerminalClasses::TermClass18,
-            JsonTerminalClasses::TermClass19, JsonTerminalClasses::eof
+        static __RUSTYLR_TSET3: [JsonTerminalClasses; 6usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass13,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset24: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19,
-            JsonTerminalClasses::eof
+        static __RUSTYLR_TSET24: [JsonTerminalClasses; 5usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset25: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass0, JsonTerminalClasses::TermClass1,
-            JsonTerminalClasses::eof
+        static __RUSTYLR_TSET25: [JsonTerminalClasses; 3usize] = [
+            JsonTerminalClasses::TermClass0,
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset10: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass1, JsonTerminalClasses::TermClass3,
-            JsonTerminalClasses::TermClass4, JsonTerminalClasses::TermClass5,
-            JsonTerminalClasses::TermClass6, JsonTerminalClasses::TermClass7,
-            JsonTerminalClasses::TermClass8, JsonTerminalClasses::TermClass9,
-            JsonTerminalClasses::TermClass10, JsonTerminalClasses::TermClass11,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass13,
-            JsonTerminalClasses::TermClass14, JsonTerminalClasses::TermClass15,
-            JsonTerminalClasses::TermClass16, JsonTerminalClasses::TermClass17,
-            JsonTerminalClasses::TermClass18, JsonTerminalClasses::TermClass19,
-            JsonTerminalClasses::TermClass20, JsonTerminalClasses::TermClass21,
-            JsonTerminalClasses::TermClass22, JsonTerminalClasses::TermClass23,
-            JsonTerminalClasses::TermClass24, JsonTerminalClasses::TermClass25,
-            JsonTerminalClasses::TermClass26, JsonTerminalClasses::TermClass27,
-            JsonTerminalClasses::TermClass28, JsonTerminalClasses::TermClass29,
-            JsonTerminalClasses::TermClass30
+        static __RUSTYLR_TSET10: [JsonTerminalClasses; 29usize] = [
+            JsonTerminalClasses::TermClass1,
+            JsonTerminalClasses::TermClass3,
+            JsonTerminalClasses::TermClass4,
+            JsonTerminalClasses::TermClass5,
+            JsonTerminalClasses::TermClass6,
+            JsonTerminalClasses::TermClass7,
+            JsonTerminalClasses::TermClass8,
+            JsonTerminalClasses::TermClass9,
+            JsonTerminalClasses::TermClass10,
+            JsonTerminalClasses::TermClass11,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass13,
+            JsonTerminalClasses::TermClass14,
+            JsonTerminalClasses::TermClass15,
+            JsonTerminalClasses::TermClass16,
+            JsonTerminalClasses::TermClass17,
+            JsonTerminalClasses::TermClass18,
+            JsonTerminalClasses::TermClass19,
+            JsonTerminalClasses::TermClass20,
+            JsonTerminalClasses::TermClass21,
+            JsonTerminalClasses::TermClass22,
+            JsonTerminalClasses::TermClass23,
+            JsonTerminalClasses::TermClass24,
+            JsonTerminalClasses::TermClass25,
+            JsonTerminalClasses::TermClass26,
+            JsonTerminalClasses::TermClass27,
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::TermClass29,
+            JsonTerminalClasses::TermClass30,
         ];
-        let __rustylr_tset1: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass6, JsonTerminalClasses::TermClass7,
-            JsonTerminalClasses::TermClass9, JsonTerminalClasses::TermClass11,
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass14,
-            JsonTerminalClasses::TermClass15, JsonTerminalClasses::TermClass16,
-            JsonTerminalClasses::TermClass20, JsonTerminalClasses::TermClass21,
-            JsonTerminalClasses::TermClass27, JsonTerminalClasses::TermClass28,
-            JsonTerminalClasses::TermClass29, JsonTerminalClasses::eof
+        static __RUSTYLR_TSET1: [JsonTerminalClasses; 14usize] = [
+            JsonTerminalClasses::TermClass6,
+            JsonTerminalClasses::TermClass7,
+            JsonTerminalClasses::TermClass9,
+            JsonTerminalClasses::TermClass11,
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass14,
+            JsonTerminalClasses::TermClass15,
+            JsonTerminalClasses::TermClass16,
+            JsonTerminalClasses::TermClass20,
+            JsonTerminalClasses::TermClass21,
+            JsonTerminalClasses::TermClass27,
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::TermClass29,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset0: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass6, JsonTerminalClasses::TermClass7,
-            JsonTerminalClasses::TermClass9, JsonTerminalClasses::TermClass11,
-            JsonTerminalClasses::TermClass14, JsonTerminalClasses::TermClass15,
-            JsonTerminalClasses::TermClass20, JsonTerminalClasses::TermClass27,
-            JsonTerminalClasses::TermClass29
+        static __RUSTYLR_TSET0: [JsonTerminalClasses; 9usize] = [
+            JsonTerminalClasses::TermClass6,
+            JsonTerminalClasses::TermClass7,
+            JsonTerminalClasses::TermClass9,
+            JsonTerminalClasses::TermClass11,
+            JsonTerminalClasses::TermClass14,
+            JsonTerminalClasses::TermClass15,
+            JsonTerminalClasses::TermClass20,
+            JsonTerminalClasses::TermClass27,
+            JsonTerminalClasses::TermClass29,
         ];
-        let __rustylr_tset20: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21
+        static __RUSTYLR_TSET20: [JsonTerminalClasses; 2usize] = [
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass21,
         ];
-        let __rustylr_tset15: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass21,
-            JsonTerminalClasses::TermClass28, JsonTerminalClasses::eof
+        static __RUSTYLR_TSET15: [JsonTerminalClasses; 4usize] = [
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass21,
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset13: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass12, JsonTerminalClasses::TermClass28
+        static __RUSTYLR_TSET13: [JsonTerminalClasses; 2usize] = [
+            JsonTerminalClasses::TermClass12,
+            JsonTerminalClasses::TermClass28,
         ];
-        let __rustylr_tset19: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass14, JsonTerminalClasses::TermClass15
+        static __RUSTYLR_TSET19: [JsonTerminalClasses; 2usize] = [
+            JsonTerminalClasses::TermClass14,
+            JsonTerminalClasses::TermClass15,
         ];
-        let __rustylr_tset12: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass16
+        static __RUSTYLR_TSET12: [JsonTerminalClasses; 1usize] = [
+            JsonTerminalClasses::TermClass16,
         ];
-        let __rustylr_tset5: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass21
+        static __RUSTYLR_TSET5: [JsonTerminalClasses; 1usize] = [
+            JsonTerminalClasses::TermClass21,
         ];
-        let __rustylr_tset8: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass28
+        static __RUSTYLR_TSET8: [JsonTerminalClasses; 1usize] = [
+            JsonTerminalClasses::TermClass28,
         ];
-        let __rustylr_tset7: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass28, JsonTerminalClasses::TermClass29
+        static __RUSTYLR_TSET7: [JsonTerminalClasses; 2usize] = [
+            JsonTerminalClasses::TermClass28,
+            JsonTerminalClasses::TermClass29,
         ];
-        let __rustylr_tset9: Vec<JsonTerminalClasses> = vec![
-            JsonTerminalClasses::TermClass29
+        static __RUSTYLR_TSET9: [JsonTerminalClasses; 1usize] = [
+            JsonTerminalClasses::TermClass29,
+        ];
+        static __RUSTYLR_TSET23: [JsonTerminalClasses; 1usize] = [
+            JsonTerminalClasses::eof,
         ];
-        let __rustylr_tset23: Vec<JsonTerminalClasses> = vec![JsonTerminalClasses::eof];
         let states: Vec<
             ::rusty_lr::parser::state::IntermediateState<
                 JsonTerminalClasses,
@@ -1950,14 +2019,14 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(7, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [0, 15, 42, 43, 44, 97, 98,]; let shifted : &
-            'static [u8] = & [0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter())
-            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass0,
+            static __RULES : [u8; 7usize] = [0, 15, 42, 43, 44, 97, 98,]; static
+            __SHIFTED : [u8; 7usize] = [0, 0, 0, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(1, false)),
             (JsonTerminalClasses::TermClass1,
             ::rusty_lr::parser::state::ShiftTarget::new(2, false)),],
@@ -1966,12 +2035,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(1, false)),
@@ -1982,41 +2051,39 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![43]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [43,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); let reduce_rules = vec![44]; __reduce_map
-            .extend(__rustylr_tset1.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [44,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::eof,
-            ::rusty_lr::parser::state::ShiftTarget::new(6, true)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [98,]; let shifted : & 'static
-            [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET1.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [43,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [98,];
-            let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(|
+            let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
+            vec![44]; __reduce_map.extend(__RUSTYLR_TSET1.iter().map(| term | (* term,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            static __RULES : [u8; 1usize] = [44,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::eof,
+            ::rusty_lr::parser::state::ShiftTarget::new(6, true)),],
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [98,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 1usize] = [98,]; static
+            __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
             (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
             usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
@@ -2054,117 +2121,106 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString24,
             ::rusty_lr::parser::state::ShiftTarget::new(107, false)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(110, false)),], reduce_map : {
-            let mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [1, 2,
-            3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92,
-            93,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (&
+            ::rusty_lr::parser::state::ShiftTarget::new(110, false)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 23usize] = [1, 2, 3, 4,
+            5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, 93,];
+            static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (&
             rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
             shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass22,
             ::rusty_lr::parser::state::ShiftTarget::new(9, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static
-            [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24,
             ::rusty_lr::parser::state::ShiftTarget::new(10, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass25,
             ::rusty_lr::parser::state::ShiftTarget::new(11, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19,
             ::rusty_lr::parser::state::ShiftTarget::new(12, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [46,]; let shifted : & 'static
-            [u8] = & [4,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![46]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![46]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [46,]; let shifted : & 'static [u8] = & [5,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [46,]; static __SHIFTED : [u8; 1usize] =
+            [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26,
             ::rusty_lr::parser::state::ShiftTarget::new(14, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [47,]; let shifted : & 'static
-            [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24,
             ::rusty_lr::parser::state::ShiftTarget::new(15, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [47,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass24,
             ::rusty_lr::parser::state::ShiftTarget::new(16, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [47,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![47]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![47]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [47,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [47,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass8,
             ::rusty_lr::parser::state::ShiftTarget::new(18, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static
-            [u8] = & [1,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] =
+            [1,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass26,
             ::rusty_lr::parser::state::ShiftTarget::new(19, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass19,
             ::rusty_lr::parser::state::ShiftTarget::new(20, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [45,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![45]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![45]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [45,]; let shifted : & 'static [u8] = & [4,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [45,]; static __SHIFTED : [u8; 1usize] =
+            [4,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -2172,11 +2228,10 @@ impl JsonParser {
             (JsonTerminalClasses::TermClass15,
             ::rusty_lr::parser::state::ShiftTarget::new(22, false)),],
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [34, 35,
-            92, 93,]; let shifted : & 'static [u8] = & [1, 1, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [34, 35, 92,
+            93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -2188,22 +2243,22 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(24, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![93]; __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term,
+            vec![93]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [35, 90, 91, 92, 93, 93,]; let shifted : &
-            'static [u8] = & [2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [35, 90, 91, 92, 93, 93,]; static __SHIFTED :
+            [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![35]; __reduce_map
-            .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [35,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass14,
+            .extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [35,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(24, false)),
             (JsonTerminalClasses::TermClass15,
             ::rusty_lr::parser::state::ShiftTarget::new(24, false)),],
@@ -2212,30 +2267,30 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(24, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![91]; __reduce_map
-            .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [91,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); let reduce_rules = vec![34]; __reduce_map
-            .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [34,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass14,
+            .extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [91,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
+            let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
+            vec![34]; __reduce_map.extend(__RUSTYLR_TSET4.iter().map(| term | (* term,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            static __RULES : [u8; 1usize] = [34,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(24, false)),
             (JsonTerminalClasses::TermClass15,
             ::rusty_lr::parser::state::ShiftTarget::new(24, false)),],
@@ -2244,22 +2299,22 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(24, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![93]; __reduce_map.extend(__rustylr_tset3.iter().map(| term | (* term,
+            vec![93]; __reduce_map.extend(__RUSTYLR_TSET3.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [33, 90, 91, 92, 93, 93,]; let shifted : &
-            'static [u8] = & [1, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [33, 90, 91, 92, 93, 93,]; static __SHIFTED :
+            [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![33]; __reduce_map
-            .extend(__rustylr_tset4.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [33,]; let shifted : & 'static [u8] = & [2,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass0,
+            .extend(__RUSTYLR_TSET4.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [33,]; static __SHIFTED : [u8; 1usize] = [2,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(1, false)),
             (JsonTerminalClasses::TermClass1,
             ::rusty_lr::parser::state::ShiftTarget::new(2, false)),],
@@ -2273,23 +2328,23 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(32, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![51]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term,
+            vec![51]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term,
             reduce_rules.clone()))); let reduce_rules = vec![97]; __reduce_map
-            .extend(__rustylr_tset0.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [14, 15, 42, 43, 44, 48, 49, 50, 51, 97,]; let shifted : & 'static [u8] =
-            & [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (&
-            rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            .extend(__RUSTYLR_TSET0.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            10usize] = [14, 15, 42, 43, 44, 48, 49, 50, 51, 97,]; static __SHIFTED : [u8;
+            10usize] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED
+            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
+            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass12,
             ::rusty_lr::parser::state::ShiftTarget::new(31, false)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![48]; __reduce_map
-            .extend(__rustylr_tset5.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [48, 49,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET5.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [48, 49,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -2304,14 +2359,14 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(32, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [15, 42, 43, 44, 48, 49, 49, 97,]; let shifted
-            : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 2, 0,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass6,
+            static __RULES : [u8; 8usize] = [15, 42, 43, 44, 48, 49, 49, 97,]; static
+            __SHIFTED : [u8; 8usize] = [0, 0, 0, 0, 0, 0, 2, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(8, false)),
             (JsonTerminalClasses::TermClass7,
             ::rusty_lr::parser::state::ShiftTarget::new(13, false)),
@@ -2345,12 +2400,11 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString24,
             ::rusty_lr::parser::state::ShiftTarget::new(94, false)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(97, false)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [1, 2,
-            3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92,
-            93,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (&
+            ::rusty_lr::parser::state::ShiftTarget::new(97, false)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 23usize] = [1, 2, 3, 4,
+            5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, 93,];
+            static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (&
             rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
             shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
@@ -2359,11 +2413,10 @@ impl JsonParser {
             (JsonTerminalClasses::TermClass15,
             ::rusty_lr::parser::state::ShiftTarget::new(34, false)),],
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [34, 35,
-            92, 93,]; let shifted : & 'static [u8] = & [1, 1, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [34, 35, 92,
+            93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -2375,12 +2428,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(35, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![93]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term,
+            vec![93]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [35, 90, 91, 92, 93, 93,]; let shifted : &
-            'static [u8] = & [2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [35, 90, 91, 92, 93, 93,]; static __SHIFTED :
+            [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(35, false)),
@@ -2391,12 +2444,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(35, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(35, false)),
@@ -2407,27 +2460,26 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(35, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![93]; __reduce_map.extend(__rustylr_tset6.iter().map(| term | (* term,
+            vec![93]; __reduce_map.extend(__RUSTYLR_TSET6.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [33, 90, 91, 92, 93, 93,]; let shifted : &
-            'static [u8] = & [1, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [33, 90, 91, 92, 93, 93,]; static __SHIFTED :
+            [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass21,
             ::rusty_lr::parser::state::ShiftTarget::new(38, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [14,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![14]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![14]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [14,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [14,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -2443,11 +2495,11 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(75, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET7.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [8, 9, 10, 11, 12, 13, 42, 43, 44, 97,]; let
-            shifted : & 'static [u8] = & [1, 1, 1, 0, 0, 0, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 10usize] = [8, 9, 10, 11, 12, 13, 42, 43, 44, 97,];
+            static __SHIFTED : [u8; 10usize] = [1, 1, 1, 0, 0, 0, 0, 0, 0, 0,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -2459,12 +2511,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET7.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(40, false)),
@@ -2475,53 +2527,51 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset7.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET7.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass28,
             ::rusty_lr::parser::state::ShiftTarget::new(43, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [10,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![10]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![10]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [10,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [10,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass28,
             ::rusty_lr::parser::state::ShiftTarget::new(45, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [9,]; let shifted : & 'static [u8]
-            = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [2,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![9]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![9]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [9,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [9,]; static __SHIFTED : [u8; 1usize] = [3,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12,
             ::rusty_lr::parser::state::ShiftTarget::new(47, false)),],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![11]; __reduce_map
-            .extend(__rustylr_tset8.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [11, 12,]; let shifted : & 'static [u8] = & [1, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET8.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            2usize] = [11, 12,]; static __SHIFTED : [u8; 2usize] = [1, 1,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -2536,14 +2586,14 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(51, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [11, 12, 12, 13, 42, 43, 44, 97,]; let shifted
-            : & 'static [u8] = & [0, 0, 2, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass0,
+            static __RULES : [u8; 8usize] = [11, 12, 12, 13, 42, 43, 44, 97,]; static
+            __SHIFTED : [u8; 8usize] = [0, 0, 2, 0, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(48, false)),
             (JsonTerminalClasses::TermClass1,
             ::rusty_lr::parser::state::ShiftTarget::new(49, false)),],
@@ -2552,12 +2602,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(48, false)),
@@ -2568,28 +2618,27 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![12]; __reduce_map
-            .extend(__rustylr_tset8.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [12,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass29,
+            .extend(__RUSTYLR_TSET8.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [12,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29,
             ::rusty_lr::parser::state::ShiftTarget::new(52, false)),],
             shift_goto_map_nonterm : vec![(JsonNonTerminals::String,
-            ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [13,
-            16,]; let shifted : & 'static [u8] = & [1, 0,]; rules.iter().zip(shifted
+            ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 2usize] = [13, 16,];
+            static __SHIFTED : [u8; 2usize] = [1, 0,]; __RULES.iter().zip(__SHIFTED
             .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
             rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
@@ -2658,13 +2707,13 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet29,
             ::rusty_lr::parser::state::ShiftTarget::new(60, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![55]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term,
+            vec![55]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [16, 17, 18, 52, 53, 54, 55, 56, 57, 58, 59,
+            static __RULES : [u8; 34usize] = [16, 17, 18, 52, 53, 54, 55, 56, 57, 58, 59,
             60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
-            79, 80, 81, 82,]; let shifted : & 'static [u8] = & [1, 0, 0, 0, 0, 0, 0, 0,
+            79, 80, 81, 82,]; static __SHIFTED : [u8; 34usize] = [1, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass4,
@@ -2686,11 +2735,10 @@ impl JsonParser {
             (JsonTerminalClasses::TermClass30,
             ::rusty_lr::parser::state::ShiftTarget::new(59, false)),],
             shift_goto_map_nonterm : vec![(JsonNonTerminals::Escape,
-            ::rusty_lr::parser::state::ShiftTarget::new(59, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [17, 19,
-            20, 21, 22, 23, 24, 25, 26, 27,]; let shifted : & 'static [u8] = & [1, 0, 0,
-            0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
+            ::rusty_lr::parser::state::ShiftTarget::new(59, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 10usize] = [17, 19, 20,
+            21, 22, 23, 24, 25, 26, 27,]; static __SHIFTED : [u8; 10usize] = [1, 0, 0, 0,
+            0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
             shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
             : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
@@ -2719,13 +2767,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet31,
             ::rusty_lr::parser::state::ShiftTarget::new(55, false)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(55, false)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28,
-            29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] =
-            & [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter())
-            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            ::rusty_lr::parser::state::ShiftTarget::new(55, false)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29,
+            30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] =
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED
+            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
+            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass5,
             ::rusty_lr::parser::state::ShiftTarget::new(56, false)),
@@ -2752,13 +2799,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet31,
             ::rusty_lr::parser::state::ShiftTarget::new(56, false)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(56, false)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28,
-            29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] =
-            & [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter())
-            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            ::rusty_lr::parser::state::ShiftTarget::new(56, false)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29,
+            30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] =
+            [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED
+            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
+            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass5,
             ::rusty_lr::parser::state::ShiftTarget::new(57, false)),
@@ -2785,13 +2831,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet31,
             ::rusty_lr::parser::state::ShiftTarget::new(57, false)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(57, false)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28,
-            29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] =
-            & [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter())
-            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            ::rusty_lr::parser::state::ShiftTarget::new(57, false)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29,
+            30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] =
+            [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED
+            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
+            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass5,
             ::rusty_lr::parser::state::ShiftTarget::new(58, false)),
@@ -2818,28 +2863,27 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet31,
             ::rusty_lr::parser::state::ShiftTarget::new(58, false)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(58, false)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [27, 28,
-            29, 30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; let shifted : & 'static [u8] =
-            & [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter())
-            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            ::rusty_lr::parser::state::ShiftTarget::new(58, false)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 13usize] = [27, 28, 29,
+            30, 83, 84, 85, 86, 87, 88, 89, 92, 93,]; static __SHIFTED : [u8; 13usize] =
+            [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED
+            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
+            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![27]; __reduce_map
-            .extend(__rustylr_tset10.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [27,]; let shifted : & 'static [u8] = & [5,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET10.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [27,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![17]; __reduce_map.extend(__rustylr_tset10.iter().map(| term | (* term,
+            vec![17]; __reduce_map.extend(__RUSTYLR_TSET10.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [17,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [17,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass1,
@@ -2905,37 +2949,36 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet29,
             ::rusty_lr::parser::state::ShiftTarget::new(60, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![52]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term,
+            vec![52]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [17, 18, 52, 52, 53, 53, 56, 57, 58, 59, 60,
+            static __RULES : [u8; 33usize] = [17, 18, 52, 52, 53, 53, 56, 57, 58, 59, 60,
             61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
-            80, 81, 82,]; let shifted : & 'static [u8] = & [0, 0, 0, 1, 0, 1, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules
-            .iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            80, 81, 82,]; static __SHIFTED : [u8; 33usize] = [0, 0, 0, 1, 0, 1, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,];
+            __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![53]; __reduce_map.extend(__rustylr_tset9.iter().map(| term | (* term,
+            vec![53]; __reduce_map.extend(__RUSTYLR_TSET9.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [53,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [53,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass29,
             ::rusty_lr::parser::state::ShiftTarget::new(63, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [16,]; let shifted : & 'static
-            [u8] = & [2,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![16]; __reduce_map.extend(__rustylr_tset11.iter().map(| term | (* term,
+            vec![16]; __reduce_map.extend(__RUSTYLR_TSET11.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [16,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -2947,12 +2990,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(67, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [13, 42, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [13, 42, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(65, false)),
@@ -2963,12 +3006,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(65, false)),
@@ -2979,19 +3022,18 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset12.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET12.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass16,
             ::rusty_lr::parser::state::ShiftTarget::new(68, false)),],
-            shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            ruleset : { let rules : & 'static [u8] = & [13,]; let shifted : & 'static
-            [u8] = & [3,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            shift_goto_map_nonterm : vec![], reduce_map : Default::default(), ruleset : {
+            static __RULES : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -3004,19 +3046,19 @@ impl JsonParser {
             true)), (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(70, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset0.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET0.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [13, 15, 42, 43, 44, 97,]; let shifted : &
-            'static [u8] = & [4, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [13, 15, 42, 43, 44, 97,]; static __SHIFTED :
+            [u8; 6usize] = [4, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![13]; __reduce_map
-            .extend(__rustylr_tset13.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [13,]; let shifted : & 'static [u8] = & [5,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET13.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [13,]; static __SHIFTED : [u8; 1usize] = [5,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass6,
@@ -3053,12 +3095,11 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString24,
             ::rusty_lr::parser::state::ShiftTarget::new(77, false)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(81, false)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [1, 2,
-            3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92,
-            93,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (&
+            ::rusty_lr::parser::state::ShiftTarget::new(81, false)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 23usize] = [1, 2, 3, 4,
+            5, 6, 7, 8, 9, 10, 14, 15, 16, 31, 32, 33, 34, 35, 45, 46, 47, 92, 93,];
+            static __SHIFTED : [u8; 23usize] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (&
             rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
             shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
@@ -3067,11 +3108,10 @@ impl JsonParser {
             (JsonTerminalClasses::TermClass15,
             ::rusty_lr::parser::state::ShiftTarget::new(72, false)),],
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [34, 35,
-            92, 93,]; let shifted : & 'static [u8] = & [1, 1, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(26, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 4usize] = [34, 35, 92,
+            93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -3083,12 +3123,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(73, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![93]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term,
+            vec![93]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [35, 90, 91, 92, 93, 93,]; let shifted : &
-            'static [u8] = & [2, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [35, 90, 91, 92, 93, 93,]; static __SHIFTED :
+            [u8; 6usize] = [2, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(73, false)),
@@ -3099,12 +3139,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(73, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(73, false)),
@@ -3115,34 +3155,33 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(73, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![93]; __reduce_map.extend(__rustylr_tset14.iter().map(| term | (* term,
+            vec![93]; __reduce_map.extend(__RUSTYLR_TSET14.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [33, 90, 91, 92, 93, 93,]; let shifted : &
-            'static [u8] = & [1, 0, 0, 0, 0, 1,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [33, 90, 91, 92, 93, 93,]; static __SHIFTED :
+            [u8; 6usize] = [1, 0, 0, 0, 0, 1,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass28,
             ::rusty_lr::parser::state::ShiftTarget::new(76, false)),
             (JsonTerminalClasses::TermClass29,
             ::rusty_lr::parser::state::ShiftTarget::new(52, false)),],
             shift_goto_map_nonterm : vec![(JsonNonTerminals::String,
-            ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [8, 13,
-            16,]; let shifted : & 'static [u8] = & [2, 1, 0,]; rules.iter().zip(shifted
+            ::rusty_lr::parser::state::ShiftTarget::new(64, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 3usize] = [8, 13, 16,];
+            static __SHIFTED : [u8; 3usize] = [2, 1, 0,]; __RULES.iter().zip(__SHIFTED
             .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
             rule : rule as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![8]; __reduce_map
-            .extend(__rustylr_tset2.iter().map(| term | (* term, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { let rules : & 'static [u8]
-            = & [8,]; let shifted : & 'static [u8] = & [3,]; rules.iter().zip(shifted
-            .iter()).map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef {
-            rule : rule as usize, shifted : shifted as usize, } }).collect() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass0,
+            .extend(__RUSTYLR_TSET2.iter().map(| term | (* term, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
+            1usize] = [8,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
+            usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
+            shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(78, false)),
             (JsonTerminalClasses::TermClass1,
             ::rusty_lr::parser::state::ShiftTarget::new(79, false)),],
@@ -3151,12 +3190,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(80, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [15, 42, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(78, false)),
@@ -3167,12 +3206,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(78, false)),
@@ -3183,19 +3222,19 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset13.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET13.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term : vec![],
             shift_goto_map_nonterm : vec![], reduce_map : { let mut __reduce_map =
             std::collections::BTreeMap::new(); let reduce_rules = vec![15]; __reduce_map
-            .extend(__rustylr_tset15.iter().map(| term | (* term, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { let rules : &
-            'static [u8] = & [15,]; let shifted : & 'static [u8] = & [3,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            .extend(__RUSTYLR_TSET15.iter().map(| term | (* term, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
+            : [u8; 1usize] = [15,]; static __SHIFTED : [u8; 1usize] = [3,]; __RULES
+            .iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass13,
@@ -3205,12 +3244,12 @@ impl JsonParser {
             (JsonNonTerminals::__Group34Question35,
             ::rusty_lr::parser::state::ShiftTarget::new(85, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![96]; __reduce_map.extend(__rustylr_tset16.iter().map(| term | (* term,
+            vec![96]; __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [31, 94, 95, 96,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8;
+            4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule,
+            & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(84, false)),
@@ -3219,19 +3258,18 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(83, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(84, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [90, 91,
-            92, 93, 94,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(84, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [90, 91, 92,
+            93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![94]; __reduce_map.extend(__rustylr_tset17.iter().map(| term | (* term,
+            vec![94]; __reduce_map.extend(__RUSTYLR_TSET17.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [94,]; let shifted : & 'static [u8] = & [2,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [94,]; static __SHIFTED : [u8; 1usize] =
+            [2,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -3243,12 +3281,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(84, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset16.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET16.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass18,
             ::rusty_lr::parser::state::ShiftTarget::new(86, false)),
@@ -3259,12 +3297,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(93, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET18.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [31, 36, 37, 38, 97,]; let shifted : & 'static
-            [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED :
+            [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass10,
             ::rusty_lr::parser::state::ShiftTarget::new(87, false)),
@@ -3275,12 +3313,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(87, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [37, 39, 40, 41, 97,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [37, 39, 40, 41, 97,]; static __SHIFTED :
+            [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(89, false)),
@@ -3289,19 +3327,18 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(88, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [37, 90,
-            91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [37, 90, 91,
+            92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![37]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![37]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [37,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [37,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -3313,12 +3350,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset18.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET18.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass10,
             ::rusty_lr::parser::state::ShiftTarget::new(91, false)),
@@ -3329,12 +3366,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(91, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [38, 39, 40, 41, 97,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [38, 39, 40, 41, 97,]; static __SHIFTED :
+            [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(89, false)),
@@ -3343,27 +3380,26 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(92, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [38, 90,
-            91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(89, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [38, 90, 91,
+            92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![38]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![38]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [38,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [38,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![31]; __reduce_map.extend(__rustylr_tset2.iter().map(| term | (* term,
+            vec![31]; __reduce_map.extend(__RUSTYLR_TSET2.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [31,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [31,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -3375,12 +3411,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(80, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [15, 42, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(95, false)),
@@ -3391,12 +3427,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(95, false)),
@@ -3407,12 +3443,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset20.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET20.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass13,
             ::rusty_lr::parser::state::ShiftTarget::new(98, false)),],
@@ -3421,12 +3457,12 @@ impl JsonParser {
             (JsonNonTerminals::__Group34Question35,
             ::rusty_lr::parser::state::ShiftTarget::new(100, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![96]; __reduce_map.extend(__rustylr_tset21.iter().map(| term | (* term,
+            vec![96]; __reduce_map.extend(__RUSTYLR_TSET21.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [31, 94, 95, 96,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8;
+            4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule,
+            & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(99, false)),
@@ -3435,11 +3471,10 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(83, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(99, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [90, 91,
-            92, 93, 94,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(99, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [90, 91, 92,
+            93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -3451,12 +3486,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(99, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset21.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET21.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass18,
             ::rusty_lr::parser::state::ShiftTarget::new(101, false)),
@@ -3467,12 +3502,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(93, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset22.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET22.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [31, 36, 37, 38, 97,]; let shifted : & 'static
-            [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED :
+            [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass10,
             ::rusty_lr::parser::state::ShiftTarget::new(102, false)),
@@ -3483,12 +3518,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(102, false)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [37, 39, 40, 41, 97,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [37, 39, 40, 41, 97,]; static __SHIFTED :
+            [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(103, false)),
@@ -3497,11 +3532,10 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(88, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [37, 90,
-            91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [37, 90, 91,
+            92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -3513,12 +3547,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset22.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET22.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass10,
             ::rusty_lr::parser::state::ShiftTarget::new(105, false)),
@@ -3529,12 +3563,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(105, false)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [38, 39, 40, 41, 97,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [38, 39, 40, 41, 97,]; static __SHIFTED :
+            [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(103, false)),
@@ -3543,19 +3577,18 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(92, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [38, 90,
-            91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(103, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [38, 90, 91,
+            92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![], shift_goto_map_nonterm : vec![], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![49]; __reduce_map.extend(__rustylr_tset5.iter().map(| term | (* term,
+            vec![49]; __reduce_map.extend(__RUSTYLR_TSET5.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [49,]; let shifted : & 'static [u8] = & [3,];
-            rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
+            static __RULES : [u8; 1usize] = [49,]; static __SHIFTED : [u8; 1usize] =
+            [3,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -3567,12 +3600,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(80, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset23.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET23.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [15, 42, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [15, 42, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(108, false)),
@@ -3583,12 +3616,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(4, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset23.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET23.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 44, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 0, 1, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 44, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 0, 1, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(108, false)),
@@ -3599,12 +3632,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(3, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset23.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET23.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [42, 43, 43, 44, 97,]; let shifted : & 'static
-            [u8] = & [0, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [42, 43, 43, 44, 97,]; static __SHIFTED :
+            [u8; 5usize] = [0, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass13,
             ::rusty_lr::parser::state::ShiftTarget::new(111, false)),],
@@ -3613,12 +3646,12 @@ impl JsonParser {
             (JsonNonTerminals::__Group34Question35,
             ::rusty_lr::parser::state::ShiftTarget::new(113, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![96]; __reduce_map.extend(__rustylr_tset24.iter().map(| term | (* term,
+            vec![96]; __reduce_map.extend(__RUSTYLR_TSET24.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [31, 94, 95, 96,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 4usize] = [31, 94, 95, 96,]; static __SHIFTED : [u8;
+            4usize] = [1, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule,
+            & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
+            shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(112, false)),
@@ -3627,11 +3660,10 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(83, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(112, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [90, 91,
-            92, 93, 94,]; let shifted : & 'static [u8] = & [0, 0, 0, 0, 1,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(112, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [90, 91, 92,
+            93, 94,]; static __SHIFTED : [u8; 5usize] = [0, 0, 0, 0, 1,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -3643,12 +3675,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(112, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset24.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET24.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass18,
             ::rusty_lr::parser::state::ShiftTarget::new(114, false)),
@@ -3659,12 +3691,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(93, false)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset25.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET25.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [31, 36, 37, 38, 97,]; let shifted : & 'static
-            [u8] = & [2, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [31, 36, 37, 38, 97,]; static __SHIFTED :
+            [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass10,
             ::rusty_lr::parser::state::ShiftTarget::new(115, false)),
@@ -3675,12 +3707,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(115, false)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [37, 39, 40, 41, 97,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [37, 39, 40, 41, 97,]; static __SHIFTED :
+            [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(116, false)),
@@ -3689,11 +3721,10 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(88, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [37, 90,
-            91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [37, 90, 91,
+            92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass14,
@@ -3705,12 +3736,12 @@ impl JsonParser {
             (JsonNonTerminals::_TermSet33,
             ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : { let
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![90]; __reduce_map.extend(__rustylr_tset25.iter().map(| term | (* term,
+            vec![90]; __reduce_map.extend(__RUSTYLR_TSET25.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [90, 90, 91, 91, 92, 93,]; let shifted : &
-            'static [u8] = & [0, 1, 0, 1, 0, 0,]; rules.iter().zip(shifted.iter()).map(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 6usize] = [90, 90, 91, 91, 92, 93,]; static __SHIFTED :
+            [u8; 6usize] = [0, 1, 0, 1, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter())
+            .map(| (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule
+            as usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass10,
             ::rusty_lr::parser::state::ShiftTarget::new(118, false)),
@@ -3721,12 +3752,12 @@ impl JsonParser {
             (JsonNonTerminals::_LiteralString36,
             ::rusty_lr::parser::state::ShiftTarget::new(118, false)),], reduce_map : {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
-            vec![97]; __reduce_map.extend(__rustylr_tset19.iter().map(| term | (* term,
+            vec![97]; __reduce_map.extend(__RUSTYLR_TSET19.iter().map(| term | (* term,
             reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
-            let rules : & 'static [u8] = & [38, 39, 40, 41, 97,]; let shifted : & 'static
-            [u8] = & [1, 0, 0, 0, 0,]; rules.iter().zip(shifted.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            static __RULES : [u8; 5usize] = [38, 39, 40, 41, 97,]; static __SHIFTED :
+            [u8; 5usize] = [1, 0, 0, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(|
+            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
+            usize, shifted : shifted as usize, } }).collect() } },
             ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(116, false)),
@@ -3735,11 +3766,10 @@ impl JsonParser {
             shift_goto_map_nonterm : vec![(JsonNonTerminals::_DigitPlus32,
             ::rusty_lr::parser::state::ShiftTarget::new(92, true)),
             (JsonNonTerminals::_TermSet33,
-            ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, ruleset : { let rules : & 'static [u8] = & [38, 90,
-            91, 92, 93,]; let shifted : & 'static [u8] = & [2, 0, 0, 0, 0,]; rules.iter()
-            .zip(shifted.iter()).map(| (& rule, & shifted) | {
+            ::rusty_lr::parser::state::ShiftTarget::new(116, true)),], reduce_map :
+            Default::default(), ruleset : { static __RULES : [u8; 5usize] = [38, 90, 91,
+            92, 93,]; static __SHIFTED : [u8; 5usize] = [2, 0, 0, 0, 0,]; __RULES.iter()
+            .zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
             ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } },
         ];
