From 08dd1079835d42429cb3341260cd1a9387450447 Mon Sep 17 00:00:00 2001
From: Taehwan Kim <ehwank98@gmail.com>
Date: Fri, 3 Oct 2025 23:53:11 +0900
Subject: [PATCH 1/3] emit terminal sets to static variables

---
 rusty_lr_parser/src/emit.rs                   |   5 +-
 rusty_lr_parser/src/parser/parser_expanded.rs | 504 ++++++++++--------
 scripts/diff/calculator.rs                    |  31 +-
 scripts/diff/calculator_u8.rs                 | 113 ++--
 scripts/diff/json.rs                          | 441 ++++++++-------
 5 files changed, 629 insertions(+), 465 deletions(-)

diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs
index 24346f16..12b9e5cc 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 {
@@ -796,6 +796,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 +812,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..a63d5d53 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<
@@ -7476,7 +7548,7 @@ 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) | {
@@ -7485,7 +7557,7 @@ impl GrammarParser {
             ::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())));
+            .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
@@ -7527,7 +7599,7 @@ 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
@@ -7540,7 +7612,7 @@ impl GrammarParser {
             ::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())));
+            .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) | {
@@ -7573,7 +7645,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7582,7 +7654,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7633,7 +7705,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7665,7 +7737,7 @@ 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 : &
@@ -7679,7 +7751,7 @@ impl GrammarParser {
             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) | {
@@ -7688,7 +7760,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7706,7 +7778,7 @@ 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
@@ -7718,7 +7790,7 @@ 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())));
+            .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) | {
@@ -7738,7 +7810,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7747,7 +7819,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7758,7 +7830,7 @@ 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())));
+            .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) | {
@@ -7778,7 +7850,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7787,7 +7859,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7796,7 +7868,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7810,7 +7882,7 @@ 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
@@ -7819,7 +7891,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7837,7 +7909,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7846,7 +7918,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7877,7 +7949,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7886,7 +7958,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7895,7 +7967,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7938,7 +8010,7 @@ 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())));
+            .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) | {
@@ -7947,7 +8019,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -7988,7 +8060,7 @@ 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())));
+            .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) | {
@@ -8030,7 +8102,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8051,7 +8123,7 @@ 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())));
+            .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) | {
@@ -8075,7 +8147,7 @@ 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,
@@ -8098,7 +8170,7 @@ 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())));
+            .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) | {
@@ -8107,7 +8179,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8146,7 +8218,7 @@ 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
@@ -8157,7 +8229,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8166,7 +8238,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8192,7 +8264,7 @@ 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,
@@ -8208,7 +8280,7 @@ 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
+            .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) | {
@@ -8226,7 +8298,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8244,7 +8316,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8262,7 +8334,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8280,7 +8352,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8298,7 +8370,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8319,7 +8391,7 @@ 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
+            .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, &
@@ -8339,7 +8411,7 @@ impl GrammarParser {
             ::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
+            .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) | {
@@ -8371,7 +8443,7 @@ 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 : &
@@ -8382,7 +8454,7 @@ impl GrammarParser {
             ::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
+            .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) | {
@@ -8391,7 +8463,7 @@ impl GrammarParser {
             ::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) | {
@@ -8412,7 +8484,7 @@ 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
+            .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, &
@@ -8438,7 +8510,7 @@ 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] =
@@ -8449,7 +8521,7 @@ impl GrammarParser {
             ::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) | {
@@ -8465,7 +8537,7 @@ 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()
@@ -8503,7 +8575,7 @@ impl GrammarParser {
             ::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) | {
@@ -8512,7 +8584,7 @@ impl GrammarParser {
             ::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) | {
@@ -8521,7 +8593,7 @@ impl GrammarParser {
             ::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())));
+            .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
@@ -8529,7 +8601,7 @@ impl GrammarParser {
             ::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())));
+            .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
@@ -8548,7 +8620,7 @@ impl GrammarParser {
             ::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())));
+            .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
@@ -8556,7 +8628,7 @@ impl GrammarParser {
             ::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())));
+            .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
@@ -8564,7 +8636,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8573,7 +8645,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8585,7 +8657,7 @@ 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())
@@ -8594,7 +8666,7 @@ impl GrammarParser {
             ::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
+            __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) | {
@@ -8606,7 +8678,7 @@ 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) | {
@@ -8615,7 +8687,7 @@ impl GrammarParser {
             ::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) | {
@@ -8624,7 +8696,7 @@ impl GrammarParser {
             ::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
+            .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) | {
@@ -8633,7 +8705,7 @@ impl GrammarParser {
             ::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
+            .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) | {
@@ -8712,7 +8784,7 @@ impl GrammarParser {
             ::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) | {
@@ -8721,7 +8793,7 @@ impl GrammarParser {
             ::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) | {
@@ -8745,7 +8817,7 @@ impl GrammarParser {
             ::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) | {
@@ -8754,7 +8826,7 @@ impl GrammarParser {
             ::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) | {
@@ -8789,7 +8861,7 @@ impl GrammarParser {
             ::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) | {
@@ -8813,7 +8885,7 @@ impl GrammarParser {
             ::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) | {
@@ -8932,7 +9004,7 @@ impl GrammarParser {
             ::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) | {
@@ -8941,7 +9013,7 @@ impl GrammarParser {
             ::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) | {
@@ -9047,7 +9119,7 @@ impl GrammarParser {
             ::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) | {
@@ -9056,7 +9128,7 @@ impl GrammarParser {
             ::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) | {
@@ -9074,7 +9146,7 @@ impl GrammarParser {
             ::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) | {
@@ -9103,7 +9175,7 @@ impl GrammarParser {
             ::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) | {
@@ -9121,7 +9193,7 @@ impl GrammarParser {
             ::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) | {
@@ -9229,7 +9301,7 @@ impl GrammarParser {
             ::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) | {
@@ -9335,7 +9407,7 @@ impl GrammarParser {
             ::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) | {
@@ -9443,7 +9515,7 @@ impl GrammarParser {
             ::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) | {
@@ -9549,7 +9621,7 @@ impl GrammarParser {
             ::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) | {
@@ -9657,7 +9729,7 @@ impl GrammarParser {
             ::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) | {
@@ -9763,7 +9835,7 @@ impl GrammarParser {
             ::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) | {
@@ -9871,7 +9943,7 @@ impl GrammarParser {
             ::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) | {
@@ -9977,7 +10049,7 @@ impl GrammarParser {
             ::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) | {
@@ -9997,7 +10069,7 @@ impl GrammarParser {
             ::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) | {
@@ -10015,7 +10087,7 @@ impl GrammarParser {
             ::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) | {
@@ -10035,7 +10107,7 @@ impl GrammarParser {
             ::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) | {
@@ -10053,7 +10125,7 @@ impl GrammarParser {
             ::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) | {
@@ -10088,7 +10160,7 @@ impl GrammarParser {
             ::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) | {
@@ -10112,7 +10184,7 @@ impl GrammarParser {
             ::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) | {
@@ -10132,7 +10204,7 @@ impl GrammarParser {
             ::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) | {
@@ -10150,7 +10222,7 @@ impl GrammarParser {
             ::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) | {
@@ -10170,7 +10242,7 @@ impl GrammarParser {
             ::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) | {
@@ -10188,7 +10260,7 @@ impl GrammarParser {
             ::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) | {
@@ -10204,7 +10276,7 @@ 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())
@@ -10213,7 +10285,7 @@ impl GrammarParser {
             ::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) | {
@@ -10231,7 +10303,7 @@ impl GrammarParser {
             ::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) | {
@@ -10242,7 +10314,7 @@ 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
+            .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) | {
@@ -10251,7 +10323,7 @@ impl GrammarParser {
             ::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) | {
@@ -10269,7 +10341,7 @@ impl GrammarParser {
             ::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) | {
@@ -10377,7 +10449,7 @@ impl GrammarParser {
             ::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) | {
@@ -10483,7 +10555,7 @@ impl GrammarParser {
             ::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) | {
@@ -10591,7 +10663,7 @@ impl GrammarParser {
             ::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) | {
@@ -10697,7 +10769,7 @@ impl GrammarParser {
             ::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) | {
@@ -10715,7 +10787,7 @@ impl GrammarParser {
             ::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) | {
@@ -10724,7 +10796,7 @@ impl GrammarParser {
             ::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) | {
@@ -10744,7 +10816,7 @@ 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,
             50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
@@ -10757,7 +10829,7 @@ impl GrammarParser {
             ::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) | {
diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs
index a2fd1f72..9365a241 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<
@@ -720,7 +725,7 @@ impl EParser {
             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) | {
@@ -744,7 +749,7 @@ impl EParser {
             ::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())));
+            .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) | {
@@ -765,7 +770,7 @@ impl EParser {
             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) | {
@@ -775,7 +780,7 @@ impl EParser {
             ::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())));
+            .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) | {
@@ -795,7 +800,7 @@ impl EParser {
             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) | {
@@ -811,7 +816,7 @@ impl EParser {
             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) | {
diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs
index c6d47155..aa5cbf96 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,7 +1022,7 @@ 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()
@@ -1014,7 +1031,7 @@ impl EParser {
             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) | {
@@ -1051,7 +1068,7 @@ 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()
@@ -1064,7 +1081,7 @@ 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) |
@@ -1074,7 +1091,7 @@ impl EParser {
             ::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())));
+            .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) | {
@@ -1082,7 +1099,7 @@ impl EParser {
             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) | {
@@ -1117,7 +1134,7 @@ 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()
@@ -1145,7 +1162,7 @@ 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, &
@@ -1154,7 +1171,7 @@ impl EParser {
             ::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())));
+            .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 {
@@ -1171,7 +1188,7 @@ 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()
@@ -1185,7 +1202,7 @@ 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) |
@@ -1220,7 +1237,7 @@ 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()
@@ -1231,7 +1248,7 @@ impl EParser {
             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())));
+            .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) | {
@@ -1239,7 +1256,7 @@ impl EParser {
             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) | {
@@ -1247,7 +1264,7 @@ impl EParser {
             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) | {
@@ -1266,7 +1283,7 @@ 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
@@ -1275,7 +1292,7 @@ impl EParser {
             ::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())));
+            .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 {
@@ -1283,7 +1300,7 @@ impl EParser {
             ::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())));
+            .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 {
@@ -1300,7 +1317,7 @@ 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()
@@ -1311,7 +1328,7 @@ impl EParser {
             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())));
+            .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) | {
diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs
index d4c90287..dfe4321b 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,7 +2019,7 @@ 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())
@@ -1966,7 +2035,7 @@ 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, &
@@ -1982,7 +2051,7 @@ 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, &
@@ -1991,7 +2060,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -1999,7 +2068,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -2097,7 +2166,7 @@ impl JsonParser {
             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) | {
@@ -2129,7 +2198,7 @@ impl JsonParser {
             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) | {
@@ -2161,7 +2230,7 @@ impl JsonParser {
             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) | {
@@ -2188,7 +2257,7 @@ 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(|
@@ -2197,7 +2266,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -2212,7 +2281,7 @@ 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(|
@@ -2221,7 +2290,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -2229,7 +2298,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -2244,7 +2313,7 @@ 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(|
@@ -2253,7 +2322,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -2273,9 +2342,9 @@ 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())));
+            .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(| (&
@@ -2286,7 +2355,7 @@ impl JsonParser {
             ::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())));
+            .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) | {
@@ -2304,7 +2373,7 @@ 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
@@ -2375,7 +2444,7 @@ 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(|
@@ -2391,7 +2460,7 @@ 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(|
@@ -2407,7 +2476,7 @@ 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(|
@@ -2424,7 +2493,7 @@ impl JsonParser {
             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) | {
@@ -2443,7 +2512,7 @@ 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()
@@ -2459,7 +2528,7 @@ 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, &
@@ -2475,7 +2544,7 @@ 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, &
@@ -2492,7 +2561,7 @@ impl JsonParser {
             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) | {
@@ -2508,7 +2577,7 @@ impl JsonParser {
             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) | {
@@ -2518,7 +2587,7 @@ impl JsonParser {
             ::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())));
+            .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) | {
@@ -2536,7 +2605,7 @@ 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
@@ -2552,7 +2621,7 @@ 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, &
@@ -2568,7 +2637,7 @@ 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, &
@@ -2577,7 +2646,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -2658,7 +2727,7 @@ 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,
             60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
@@ -2828,7 +2897,7 @@ impl JsonParser {
             ::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
+            .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) | {
@@ -2836,7 +2905,7 @@ impl JsonParser {
             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) | {
@@ -2905,7 +2974,7 @@ 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,
             61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
@@ -2916,7 +2985,7 @@ impl JsonParser {
             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) | {
@@ -2932,7 +3001,7 @@ impl JsonParser {
             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) | {
@@ -2947,7 +3016,7 @@ 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, &
@@ -2963,7 +3032,7 @@ 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, &
@@ -2979,7 +3048,7 @@ 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, &
@@ -3004,7 +3073,7 @@ 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(|
@@ -3013,7 +3082,7 @@ impl JsonParser {
             ::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
+            .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) | {
@@ -3083,7 +3152,7 @@ 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(|
@@ -3099,7 +3168,7 @@ 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(|
@@ -3115,7 +3184,7 @@ 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(|
@@ -3136,7 +3205,7 @@ impl JsonParser {
             ::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())));
+            .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 {
@@ -3151,7 +3220,7 @@ 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, &
@@ -3167,7 +3236,7 @@ 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, &
@@ -3183,7 +3252,7 @@ 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, &
@@ -3192,7 +3261,7 @@ impl JsonParser {
             ::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
+            .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) | {
@@ -3205,7 +3274,7 @@ 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, &
@@ -3228,7 +3297,7 @@ impl JsonParser {
             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) | {
@@ -3243,7 +3312,7 @@ 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(|
@@ -3259,7 +3328,7 @@ 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, &
@@ -3275,7 +3344,7 @@ 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, &
@@ -3298,7 +3367,7 @@ impl JsonParser {
             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) | {
@@ -3313,7 +3382,7 @@ 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(|
@@ -3329,7 +3398,7 @@ 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, &
@@ -3352,7 +3421,7 @@ impl JsonParser {
             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) | {
@@ -3360,7 +3429,7 @@ impl JsonParser {
             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) | {
@@ -3375,7 +3444,7 @@ 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, &
@@ -3391,7 +3460,7 @@ 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, &
@@ -3407,7 +3476,7 @@ 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, &
@@ -3421,7 +3490,7 @@ 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, &
@@ -3451,7 +3520,7 @@ 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(|
@@ -3467,7 +3536,7 @@ 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, &
@@ -3483,7 +3552,7 @@ 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, &
@@ -3513,7 +3582,7 @@ 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(|
@@ -3529,7 +3598,7 @@ 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, &
@@ -3552,7 +3621,7 @@ impl JsonParser {
             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) | {
@@ -3567,7 +3636,7 @@ 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, &
@@ -3583,7 +3652,7 @@ 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, &
@@ -3599,7 +3668,7 @@ 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, &
@@ -3613,7 +3682,7 @@ 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, &
@@ -3643,7 +3712,7 @@ 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(|
@@ -3659,7 +3728,7 @@ 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, &
@@ -3675,7 +3744,7 @@ 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, &
@@ -3705,7 +3774,7 @@ 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(|
@@ -3721,7 +3790,7 @@ 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, &

From c02b34f96fff3eaaa1495c2afe246b19e4b49bac Mon Sep 17 00:00:00 2001
From: Taehwan Kim <ehwank98@gmail.com>
Date: Fri, 3 Oct 2025 23:57:21 +0900
Subject: [PATCH 2/3] emit ruleset and shifted static

---
 rusty_lr_parser/src/emit.rs                   |    7 +-
 rusty_lr_parser/src/parser/parser_expanded.rs | 1246 +++++++++--------
 scripts/diff/calculator.rs                    |   90 +-
 scripts/diff/calculator_u8.rs                 |  200 +--
 scripts/diff/json.rs                          | 1044 +++++++-------
 5 files changed, 1307 insertions(+), 1280 deletions(-)

diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs
index 12b9e5cc..dbece0e2 100644
--- a/rusty_lr_parser/src/emit.rs
+++ b/rusty_lr_parser/src/emit.rs
@@ -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);
@@ -775,13 +776,13 @@ impl Grammar {
                             __reduce_map.into_iter().collect()
                         },
                         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,
diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs
index a63d5d53..7d008950 100644
--- a/rusty_lr_parser/src/parser/parser_expanded.rs
+++ b/rusty_lr_parser/src/parser/parser_expanded.rs
@@ -7534,14 +7534,14 @@ impl GrammarParser {
             (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,
+            .into_iter().collect() }, 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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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::parengroup,
             ::rusty_lr_core::parser::state::ShiftTarget::new(2, true)),],
@@ -7550,27 +7550,28 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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() } },
+            __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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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 :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)),
@@ -7601,21 +7602,21 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            __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 :
@@ -7636,28 +7637,28 @@ impl GrammarParser {
             (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::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            .into_iter().collect() }, 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) | {
+            .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) | {
+            .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 :
@@ -7665,19 +7666,19 @@ impl GrammarParser {
             ::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(|
-            (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            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(|
-            (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            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 :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)),
@@ -7696,19 +7697,19 @@ impl GrammarParser {
             (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(|
-            (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            .into_iter().collect() }, 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) | {
+            .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 :
@@ -7739,12 +7740,12 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),],
@@ -7753,17 +7754,17 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            .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 :
@@ -7780,9 +7781,9 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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 :
@@ -7791,9 +7792,9 @@ impl GrammarParser {
             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) | {
+            __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 :
@@ -7803,26 +7804,26 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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) | {
+            .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 :
@@ -7831,9 +7832,9 @@ impl GrammarParser {
             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) | {
+            __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 :
@@ -7843,35 +7844,35 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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) | {
+            .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) | {
+            .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 :
@@ -7884,17 +7885,18 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            .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 :
@@ -7902,26 +7904,26 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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) | {
+            .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 :
@@ -7941,36 +7943,36 @@ impl GrammarParser {
             ::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) | {
+            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) | {
+            .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) | {
+            .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) | {
+            .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 :
@@ -7991,12 +7993,12 @@ impl GrammarParser {
             (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::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            .into_iter().collect() }, 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 :
             vec![(GrammarTerminalClasses::plus,
             ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)),
@@ -8011,18 +8013,18 @@ impl GrammarParser {
             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 :
+            __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) | {
+            .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 :
@@ -8043,12 +8045,12 @@ impl GrammarParser {
             (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::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            .into_iter().collect() }, 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 :
             vec![(GrammarTerminalClasses::plus,
             ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)),
@@ -8061,9 +8063,9 @@ impl GrammarParser {
             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) | {
+            __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 :
@@ -8084,28 +8086,28 @@ impl GrammarParser {
             (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(|
-            (& rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule
-            as usize, shifted : shifted as usize, } }).collect() } },
+            .into_iter().collect() }, 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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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 :
@@ -8124,11 +8126,11 @@ impl GrammarParser {
             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() } },
+            __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)),
@@ -8149,10 +8151,10 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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 :
@@ -8171,18 +8173,18 @@ impl GrammarParser {
             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() } },
+            __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) | {
+            .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 :
@@ -8192,10 +8194,10 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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,
             ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)),
@@ -8220,28 +8222,28 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            .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) | {
+            .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 :
@@ -8266,9 +8268,9 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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 :
@@ -8281,9 +8283,9 @@ impl GrammarParser {
             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) | {
+            .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 :
@@ -8291,17 +8293,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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 :
@@ -8309,17 +8311,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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 :
@@ -8327,17 +8329,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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 :
@@ -8345,17 +8347,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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 :
@@ -8363,17 +8365,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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 :
@@ -8392,11 +8394,11 @@ impl GrammarParser {
             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() } },
+            .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)),
@@ -8404,17 +8406,17 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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) | {
+            .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 :
@@ -8445,19 +8447,19 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            .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 :
@@ -8465,8 +8467,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![78];
             __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 :
@@ -8485,11 +8487,11 @@ impl GrammarParser {
             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() } },
+            .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)),
@@ -8512,10 +8514,10 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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 :
@@ -8523,8 +8525,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![79];
             __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 :
@@ -8539,9 +8541,9 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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 :
@@ -8553,10 +8555,10 @@ impl GrammarParser {
             ::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(| (&
-            rule, & shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            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 :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)),
@@ -8567,9 +8569,9 @@ impl GrammarParser {
             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) | {
+            .into_iter().collect() }, 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 :
@@ -8577,8 +8579,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![39];
             __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 :
@@ -8586,26 +8588,28 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![40];
             __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() } },
+            __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() } },
+            __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)),
@@ -8613,42 +8617,44 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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() } },
+            __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() } },
+            __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) | {
+            .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) | {
+            .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 :
@@ -8659,17 +8665,17 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            .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 :
@@ -8680,35 +8686,35 @@ impl GrammarParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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_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) | {
+            .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) | {
+            .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 :
@@ -8748,12 +8754,12 @@ impl GrammarParser {
             ::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,
+            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,]; let shifted : & 'static [u8] = & [1, 1, 1, 1,
+            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 :
+            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,
@@ -8767,9 +8773,9 @@ impl GrammarParser {
             (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) | {
+            .into_iter().collect() }, 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 :
@@ -8777,17 +8783,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -8795,8 +8801,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![143];
             __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 :
@@ -8809,9 +8815,9 @@ impl GrammarParser {
             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) | {
+            .into_iter().collect() }, 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 :
@@ -8819,8 +8825,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![50];
             __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 :
@@ -8828,8 +8834,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![144];
             __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 :
@@ -8844,9 +8850,9 @@ impl GrammarParser {
             (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) | {
+            .into_iter().collect() }, 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 :
@@ -8854,17 +8860,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -8877,9 +8883,9 @@ impl GrammarParser {
             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) | {
+            .into_iter().collect() }, 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 :
@@ -8887,8 +8893,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![52];
             __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 :
@@ -8898,10 +8904,10 @@ impl GrammarParser {
             ::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,
-            shifted : shifted as usize, } }).collect() } },
+            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,
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
@@ -8992,22 +8998,22 @@ impl GrammarParser {
             (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,
-            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,
+            .into_iter().collect() }, 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,];
+            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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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![42];
             __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 :
@@ -9015,8 +9021,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![141];
             __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 :
@@ -9107,13 +9113,13 @@ impl GrammarParser {
             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,
+            .into_iter().collect() }, 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,]; 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) | {
+            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 :
@@ -9121,8 +9127,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![41];
             __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 :
@@ -9130,8 +9136,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![142];
             __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 :
@@ -9139,17 +9145,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -9159,26 +9165,26 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -9186,17 +9192,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -9289,22 +9295,22 @@ impl GrammarParser {
             (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,
-            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,
+            .into_iter().collect() }, 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,];
+            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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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![47];
             __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 :
@@ -9395,13 +9401,13 @@ impl GrammarParser {
             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,
+            .into_iter().collect() }, 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,]; 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) | {
+            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 :
@@ -9409,8 +9415,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![46];
             __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 :
@@ -9503,22 +9509,22 @@ impl GrammarParser {
             (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,
-            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,
+            .into_iter().collect() }, 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,];
+            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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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![49];
             __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 :
@@ -9609,13 +9615,13 @@ impl GrammarParser {
             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,
+            .into_iter().collect() }, 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,]; 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) | {
+            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 :
@@ -9623,8 +9629,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![48];
             __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 :
@@ -9717,22 +9723,22 @@ impl GrammarParser {
             (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,
-            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,
+            .into_iter().collect() }, 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,];
+            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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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![57];
             __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 :
@@ -9823,13 +9829,13 @@ impl GrammarParser {
             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,
+            .into_iter().collect() }, 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,]; 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) | {
+            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 :
@@ -9837,8 +9843,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![56];
             __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 :
@@ -9931,22 +9937,22 @@ impl GrammarParser {
             (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,
-            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,
+            .into_iter().collect() }, 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,];
+            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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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![59];
             __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 :
@@ -10037,13 +10043,13 @@ impl GrammarParser {
             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,
+            .into_iter().collect() }, 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,]; 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) | {
+            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 :
@@ -10051,8 +10057,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![58];
             __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 :
@@ -10062,17 +10068,17 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10080,17 +10086,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10100,17 +10106,17 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10118,17 +10124,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10143,9 +10149,9 @@ impl GrammarParser {
             (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) | {
+            .into_iter().collect() }, 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 :
@@ -10153,17 +10159,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10176,9 +10182,9 @@ impl GrammarParser {
             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) | {
+            .into_iter().collect() }, 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 :
@@ -10186,8 +10192,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![54];
             __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 :
@@ -10197,17 +10203,17 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10215,17 +10221,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10235,17 +10241,17 @@ impl GrammarParser {
             ::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 :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10253,17 +10259,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10278,17 +10284,17 @@ impl GrammarParser {
             { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules
             = 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_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 :
@@ -10296,17 +10302,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10315,9 +10321,9 @@ impl GrammarParser {
             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) | {
+            .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 :
@@ -10325,8 +10331,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![146];
             __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 :
@@ -10334,17 +10340,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10437,22 +10443,22 @@ impl GrammarParser {
             (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,
-            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,
+            .into_iter().collect() }, 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,];
+            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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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![71];
             __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 :
@@ -10543,13 +10549,13 @@ impl GrammarParser {
             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,
+            .into_iter().collect() }, 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,]; 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) | {
+            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 :
@@ -10557,8 +10563,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![70];
             __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 :
@@ -10651,22 +10657,22 @@ impl GrammarParser {
             (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,
-            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,
+            .into_iter().collect() }, 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,];
+            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,]; rules.iter().zip(shifted.iter()).map(| (& rule, & shifted) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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![73];
             __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 :
@@ -10757,13 +10763,13 @@ impl GrammarParser {
             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,
+            .into_iter().collect() }, 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,]; 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) | {
+            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 :
@@ -10771,8 +10777,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![72];
             __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 :
@@ -10780,17 +10786,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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_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 :
@@ -10798,8 +10804,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![75];
             __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 :
@@ -10818,12 +10824,12 @@ impl GrammarParser {
             { let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules
             = 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 :
@@ -10831,8 +10837,8 @@ impl GrammarParser {
             = std::collections::BTreeMap::new(); let reduce_rules = vec![150];
             __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 :
@@ -10840,17 +10846,17 @@ impl GrammarParser {
             ::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) | {
-            ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize, shifted :
-            shifted as usize, } }).collect() } },
+            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() } },
+            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 9365a241..c11c3010 100644
--- a/scripts/diff/calculator.rs
+++ b/scripts/diff/calculator.rs
@@ -718,17 +718,17 @@ impl EParser {
             ::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) | {
+            .into_iter().collect() }, 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,
             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,
@@ -740,9 +740,9 @@ impl EParser {
             ::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) | {
+            .into_iter().collect() }, 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,
@@ -750,9 +750,9 @@ impl EParser {
             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) | {
+            __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,
@@ -763,17 +763,17 @@ impl EParser {
             ::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) | {
+            .into_iter().collect() }, 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,
             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,
@@ -781,9 +781,9 @@ impl EParser {
             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) | {
+            __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,
@@ -793,49 +793,51 @@ impl EParser {
             ::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) | {
+            .into_iter().collect() }, 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,
             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) | {
-            ::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,
-            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) | {
+            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, 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::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) | {
-            ::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(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            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 : { 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() } },
         ];
         let states: Vec<EState> = states.into_iter().map(|state| state.into()).collect();
         Self { rules, states }
diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs
index aa5cbf96..e07ee481 100644
--- a/scripts/diff/calculator_u8.rs
+++ b/scripts/diff/calculator_u8.rs
@@ -1024,17 +1024,17 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
             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,
@@ -1045,17 +1045,17 @@ impl EParser {
             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) | {
+            .into_iter().collect() }, 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(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            .into_iter().collect() }, 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![(ETerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(6, false)),],
@@ -1070,9 +1070,9 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
@@ -1083,26 +1083,27 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            __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,
             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,
@@ -1118,12 +1119,12 @@ impl EParser {
             (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() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(ETerminalClasses::TermClass0,
+            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)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Number,
             ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P,
@@ -1136,9 +1137,9 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
@@ -1150,9 +1151,9 @@ 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(); __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) | {
+            .into_iter().collect() }, 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,
@@ -1164,20 +1165,20 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
+            __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,
@@ -1190,9 +1191,9 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
@@ -1204,11 +1205,12 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -1221,12 +1223,12 @@ impl EParser {
             (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() } },
-            ::rusty_lr::parser::state::IntermediateState { shift_goto_map_term :
-            vec![(ETerminalClasses::TermClass0,
+            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)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Number,
             ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P,
@@ -1239,9 +1241,9 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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 :
@@ -1249,25 +1251,25 @@ impl EParser {
             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) | {
+            __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,
             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,
             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,
@@ -1285,28 +1287,28 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
@@ -1319,9 +1321,9 @@ impl EParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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 :
@@ -1329,9 +1331,9 @@ impl EParser {
             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) | {
+            __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 dfe4321b..55d07884 100644
--- a/scripts/diff/json.rs
+++ b/scripts/diff/json.rs
@@ -2021,12 +2021,12 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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)),],
@@ -2037,10 +2037,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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)),
@@ -2053,41 +2053,42 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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) | {
+            __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(|
-            (& rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as
-            usize, shifted : shifted as usize, } }).collect() } },
+            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 : { let mut __reduce_map =
+            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
+            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 : { let mut __reduce_map =
+            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
+            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 :
             vec![(JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(8, false)),
@@ -2125,115 +2126,125 @@ impl JsonParser {
             (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,
+            .into_iter().collect() }, 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,]; 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(| (&
-            rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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) | {
-            ::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,
+            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) | {
-            ::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,
+            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) | {
-            ::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,
+            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) | {
-            ::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,
-            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) | {
+            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, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { 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) | {
-            ::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,
+            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) | {
-            ::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,
+            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) | {
-            ::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,
-            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) | {
+            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, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { 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) | {
-            ::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,
+            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) | {
-            ::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,
+            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) | {
-            ::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,
-            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) | {
+            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, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { 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,
@@ -2243,9 +2254,9 @@ impl JsonParser {
             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) | {
+            .into_iter().collect() }, 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,
@@ -2259,20 +2270,20 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
+            __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)),],
@@ -2283,28 +2294,28 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
+            __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)),],
@@ -2315,20 +2326,20 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
+            __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)),],
@@ -2345,20 +2356,20 @@ impl JsonParser {
             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() } },
+            __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) | {
+            __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,
@@ -2375,12 +2386,12 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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)),
@@ -2416,12 +2427,12 @@ impl JsonParser {
             (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,
+            .into_iter().collect() }, 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,]; 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(| (&
-            rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(26, false)),
@@ -2430,9 +2441,9 @@ impl JsonParser {
             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) | {
+            .into_iter().collect() }, 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,
@@ -2446,10 +2457,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -2462,10 +2473,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -2478,25 +2489,26 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
-            ::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,
-            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) | {
+            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, 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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -2514,9 +2526,9 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
@@ -2530,10 +2542,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -2546,41 +2558,43 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
-            ::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,
-            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) | {
+            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, reduce_rules.clone())));
+            __reduce_map.into_iter().collect() }, ruleset : { 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) | {
-            ::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,
-            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) | {
+            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, 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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12,
@@ -2588,9 +2602,9 @@ impl JsonParser {
             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) | {
+            __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,
@@ -2607,12 +2621,12 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),],
@@ -2623,10 +2637,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -2639,26 +2653,26 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
+            __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
+            .into_iter().collect() }, 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 :
@@ -2729,11 +2743,11 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
@@ -2757,11 +2771,11 @@ impl JsonParser {
             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, &
-            shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize, shifted
-            : shifted as usize, } }).collect() } },
+            .into_iter().collect() }, 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 :
             vec![(JsonTerminalClasses::TermClass5,
             ::rusty_lr::parser::state::ShiftTarget::new(55, false)),
@@ -2790,13 +2804,13 @@ impl JsonParser {
             (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::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass5,
+            .into_iter().collect() }, 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)),
             (JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(56, false)),
@@ -2823,13 +2837,13 @@ impl JsonParser {
             (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::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass5,
+            .into_iter().collect() }, 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)),
             (JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(57, false)),
@@ -2856,13 +2870,13 @@ impl JsonParser {
             (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::IntermediateState { shift_goto_map_term :
-            vec![(JsonTerminalClasses::TermClass5,
+            .into_iter().collect() }, 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)),
             (JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(58, false)),
@@ -2889,26 +2903,26 @@ impl JsonParser {
             (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::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) | {
+            .into_iter().collect() }, 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 : {
+            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,
             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,
@@ -2976,35 +2990,36 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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,
             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) | {
-            ::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,
-            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) | {
+            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, reduce_rules
+            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { 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,
@@ -3018,10 +3033,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3034,10 +3049,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3050,20 +3065,21 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
-            ::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,
+            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,
             ::rusty_lr::parser::state::ShiftTarget::new(1, false)),
             (JsonTerminalClasses::TermClass1,
             ::rusty_lr::parser::state::ShiftTarget::new(2, false)),],
@@ -3075,17 +3091,17 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); 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] = & [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) | {
+            .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,
@@ -3124,12 +3140,12 @@ impl JsonParser {
             (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,
+            .into_iter().collect() }, 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,]; 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(| (&
-            rule, & shifted) | { ::rusty_lr::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(26, false)),
@@ -3138,9 +3154,9 @@ impl JsonParser {
             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) | {
+            .into_iter().collect() }, 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,
@@ -3154,10 +3170,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3170,10 +3186,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3186,10 +3202,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3198,20 +3214,20 @@ impl JsonParser {
             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
-            .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,
+            .into_iter().collect() }, 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 : {
+            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)),],
@@ -3222,10 +3238,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3238,10 +3254,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3254,17 +3270,17 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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) | {
+            .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,
@@ -3276,10 +3292,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3290,17 +3306,17 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
             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,
@@ -3314,10 +3330,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3330,10 +3346,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3346,10 +3362,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3360,17 +3376,17 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
             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,
@@ -3384,10 +3400,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3400,10 +3416,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3414,25 +3430,25 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
             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,
             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,
@@ -3446,10 +3462,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3462,10 +3478,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3478,10 +3494,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),],
@@ -3492,10 +3508,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3506,9 +3522,9 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
@@ -3522,10 +3538,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3538,10 +3554,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3554,10 +3570,10 @@ impl JsonParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3568,9 +3584,9 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
@@ -3584,10 +3600,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3600,10 +3616,10 @@ impl JsonParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3614,17 +3630,17 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
             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,
@@ -3638,10 +3654,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3654,10 +3670,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3670,10 +3686,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),],
@@ -3684,10 +3700,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3698,9 +3714,9 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
@@ -3714,10 +3730,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3730,10 +3746,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3746,10 +3762,10 @@ impl JsonParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3760,9 +3776,9 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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,
@@ -3776,10 +3792,10 @@ impl JsonParser {
             mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3792,10 +3808,10 @@ impl JsonParser {
             let mut __reduce_map = std::collections::BTreeMap::new(); let reduce_rules =
             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)),
@@ -3806,9 +3822,9 @@ impl JsonParser {
             (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) | {
+            .into_iter().collect() }, 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() } },
         ];

From e97141e7b2f5e54cd7a096d93b24fd4d7162d8dc Mon Sep 17 00:00:00 2001
From: Taehwan Kim <ehwank98@gmail.com>
Date: Sat, 4 Oct 2025 00:00:26 +0900
Subject: [PATCH 3/3] use Default if reduce_map was empty in code emit

---
 rusty_lr_parser/src/emit.rs                   |  18 +-
 rusty_lr_parser/src/parser/parser_expanded.rs | 794 ++++++++----------
 scripts/diff/calculator.rs                    |  81 +-
 scripts/diff/calculator_u8.rs                 |  55 +-
 scripts/diff/json.rs                          | 571 ++++++-------
 5 files changed, 696 insertions(+), 823 deletions(-)

diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs
index dbece0e2..d67dc77a 100644
--- a/rusty_lr_parser/src/emit.rs
+++ b/rusty_lr_parser/src/emit.rs
@@ -766,15 +766,23 @@ 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: {
                             static __RULES: [#rule_index_typename; #ruleset_len] = [
                                 #ruleset_rules_body_stream
diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs
index 7d008950..e9763e6b 100644
--- a/rusty_lr_parser/src/parser/parser_expanded.rs
+++ b/rusty_lr_parser/src/parser/parser_expanded.rs
@@ -7533,15 +7533,14 @@ 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 : { 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,
+            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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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,
             ::rusty_lr_core::parser::state::ShiftTarget::new(2, true)),],
@@ -7566,12 +7565,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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 :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(5, true)),
@@ -7635,14 +7633,13 @@ 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 : { 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::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];
@@ -7664,21 +7661,19 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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 : { 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() } },
+            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 :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)),
@@ -7695,14 +7690,13 @@ 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 : { 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::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];
@@ -7802,12 +7796,11 @@ 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 : { 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() } },
+            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];
@@ -7842,12 +7835,11 @@ 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 : { 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() } },
+            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];
@@ -7902,12 +7894,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -7941,11 +7932,10 @@ 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 : { 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) | {
+            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 :
@@ -7991,14 +7981,13 @@ 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 : { 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::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 :
             vec![(GrammarTerminalClasses::plus,
             ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)),
@@ -8043,14 +8032,13 @@ 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 : { 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::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 :
             vec![(GrammarTerminalClasses::plus,
             ::rusty_lr_core::parser::state::ShiftTarget::new(32, true)),
@@ -8084,23 +8072,21 @@ 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 : { 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::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 : { 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() } },
+            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];
@@ -8192,12 +8178,11 @@ 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 : { 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() } },
+            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,
             ::rusty_lr_core::parser::state::ShiftTarget::new(7, true)),
@@ -8291,12 +8276,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -8309,12 +8293,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -8327,12 +8310,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -8345,12 +8327,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -8363,12 +8344,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -8404,12 +8384,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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
@@ -8553,12 +8532,11 @@ 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 : { 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() } },
+            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 :
             vec![(GrammarTerminalClasses::ident,
             ::rusty_lr_core::parser::state::ShiftTarget::new(75, true)),
@@ -8567,10 +8545,9 @@ 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 : { static __RULES : [u8; 4usize] = [6, 7,
-            39, 40,]; static __SHIFTED : [u8; 4usize] = [2, 2, 0, 0,]; __RULES.iter()
+            ::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() } },
@@ -8615,12 +8592,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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
@@ -8752,14 +8728,13 @@ 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 : { 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 :
+            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 :
             vec![(GrammarTerminalClasses::ident,
@@ -8771,22 +8746,20 @@ 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 : { 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::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 : { 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() } },
+            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];
@@ -8813,11 +8786,10 @@ 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 : { 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::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 :
@@ -8849,21 +8821,19 @@ 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 : { 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) | {
+            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 : { 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() } },
+            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];
@@ -8881,11 +8851,10 @@ 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 : { 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::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 :
@@ -8902,12 +8871,11 @@ 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 : { 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() } },
+            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,
             ::rusty_lr_core::parser::state::ShiftTarget::new(106, true)),
@@ -8997,16 +8965,15 @@ 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 : { 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,];
-            static __SHIFTED : [u8; 45usize] = [3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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];
@@ -9112,14 +9079,13 @@ 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 : { 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) | {
+            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 :
@@ -9143,12 +9109,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -9163,21 +9128,19 @@ 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 : { 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() } },
+            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 : { 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() } },
+            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];
@@ -9190,12 +9153,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -9294,16 +9256,15 @@ 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 : { 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,];
-            static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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];
@@ -9400,14 +9361,13 @@ 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 : { 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) | {
+            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 :
@@ -9508,16 +9468,15 @@ 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 : { 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,];
-            static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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];
@@ -9614,14 +9573,13 @@ 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 : { 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) | {
+            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 :
@@ -9722,16 +9680,15 @@ 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 : { 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,];
-            static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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];
@@ -9828,14 +9785,13 @@ 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 : { 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) | {
+            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 :
@@ -9936,16 +9892,15 @@ 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 : { 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,];
-            static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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];
@@ -10042,14 +9997,13 @@ 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 : { 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) | {
+            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 :
@@ -10066,12 +10020,11 @@ 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 : { 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() } },
+            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];
@@ -10084,12 +10037,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -10104,12 +10056,11 @@ 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 : { 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() } },
+            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];
@@ -10122,12 +10073,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -10148,21 +10098,19 @@ 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 : { 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) | {
+            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 : { 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() } },
+            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];
@@ -10180,11 +10128,10 @@ 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 : { 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::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 :
@@ -10201,12 +10148,11 @@ 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 : { 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() } },
+            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];
@@ -10219,12 +10165,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -10239,12 +10184,11 @@ 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 : { 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() } },
+            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];
@@ -10257,12 +10201,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -10300,12 +10243,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -10338,12 +10280,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -10442,16 +10383,15 @@ 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 : { 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,];
-            static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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];
@@ -10548,14 +10488,13 @@ 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 : { 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) | {
+            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 :
@@ -10656,16 +10595,15 @@ 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 : { 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,];
-            static __SHIFTED : [u8; 45usize] = [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            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,]; 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, 0, 0,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, &
-            shifted) | { ::rusty_lr_core::rule::ShiftedRuleRef { rule : rule as usize,
-            shifted : shifted as usize, } }).collect() } },
+            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];
@@ -10762,14 +10700,13 @@ 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 : { 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) | {
+            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 :
@@ -10784,12 +10721,11 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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];
@@ -10844,15 +10780,13 @@ impl GrammarParser {
             ::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 : { 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() } },
+            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() },
+            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,
diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs
index c11c3010..a50d2cd2 100644
--- a/scripts/diff/calculator.rs
+++ b/scripts/diff/calculator.rs
@@ -716,11 +716,10 @@ 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 : { 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::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 : {
@@ -738,11 +737,10 @@ 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 : { 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::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,
@@ -761,11 +759,10 @@ 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 : { 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::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 : {
@@ -791,10 +788,9 @@ 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 : { static __RULES : [u8; 5usize] = [2, 2,
-            3, 4, 5,]; static __SHIFTED : [u8; 5usize] = [0, 2, 0, 0, 0,]; __RULES.iter()
+            ::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 {
@@ -808,36 +804,31 @@ impl EParser {
             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 : { 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, 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) | {
+            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,
+            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::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 : { 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 : { 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() } },
+            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 :
+            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() } },
         ];
         let states: Vec<EState> = states.into_iter().map(|state| state.into()).collect();
         Self { rules, states }
diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs
index e07ee481..36d6ae93 100644
--- a/scripts/diff/calculator_u8.rs
+++ b/scripts/diff/calculator_u8.rs
@@ -1043,19 +1043,17 @@ 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 : { static __RULES : [u8; 4usize] = [5, 8,
-            9, 16,]; static __SHIFTED : [u8; 4usize] = [1, 0, 0, 1,]; __RULES.iter()
+            ::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 : { 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() } },
+            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 :
             vec![(ETerminalClasses::TermClass0,
             ::rusty_lr::parser::state::ShiftTarget::new(6, false)),],
@@ -1117,14 +1115,13 @@ 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 : { 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,
+            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)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Number,
             ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P,
@@ -1149,10 +1146,9 @@ 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 : { static __RULES : [u8; 4usize] = [4, 5,
-            8, 9,]; static __SHIFTED : [u8; 4usize] = [3, 1, 0, 0,]; __RULES.iter()
+            ::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 {
@@ -1221,14 +1217,13 @@ 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 : { 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,
+            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)),],
             shift_goto_map_nonterm : vec![(ENonTerminals::Number,
             ::rusty_lr::parser::state::ShiftTarget::new(1, true)), (ENonTerminals::P,
diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs
index 55d07884..d556b2c7 100644
--- a/scripts/diff/json.rs
+++ b/scripts/diff/json.rs
@@ -2076,19 +2076,16 @@ impl JsonParser {
             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 : { 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 : { let mut __reduce_map =
-            std::collections::BTreeMap::new(); __reduce_map.into_iter().collect() },
-            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() } },
+            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 :
             vec![(JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(8, false)),
@@ -2124,127 +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 : { 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::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 : { 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,
+            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 : { 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,
+            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 : { 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,
+            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 : { 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, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
-            1usize] = [46,]; static __SHIFTED : [u8; 1usize] = [5,]; __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,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            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 : { 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,
+            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 : { 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,
+            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 : { 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, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
-            1usize] = [47,]; static __SHIFTED : [u8; 1usize] = [4,]; __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,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            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 : { 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,
+            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 : { 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,
+            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 : { 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, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
-            1usize] = [45,]; static __SHIFTED : [u8; 1usize] = [4,]; __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,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            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,
@@ -2252,10 +2228,9 @@ 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 : { static __RULES : [u8; 4usize] = [34,
-            35, 92, 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter()
+            ::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 {
@@ -2425,24 +2400,22 @@ 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 : { 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::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 :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(26, false)),
             (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 : { static __RULES : [u8; 4usize] = [34,
-            35, 92, 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter()
+            ::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 {
@@ -2496,19 +2469,17 @@ impl JsonParser {
             ::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 : { 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, 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) | {
+            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,
+            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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass0,
@@ -2565,36 +2536,32 @@ impl JsonParser {
             ::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 : { 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, reduce_rules.clone())));
-            __reduce_map.into_iter().collect() }, ruleset : { static __RULES : [u8;
-            1usize] = [10,]; static __SHIFTED : [u8; 1usize] = [3,]; __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,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            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 : { 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, 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) | {
+            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,
+            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::rule::ShiftedRuleRef { rule : rule as usize, shifted : shifted as
             usize, } }).collect() } }, ::rusty_lr::parser::state::IntermediateState {
             shift_goto_map_term : vec![(JsonTerminalClasses::TermClass12,
@@ -2669,10 +2636,9 @@ impl JsonParser {
             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 : { static __RULES : [u8; 2usize] = [13,
-            16,]; static __SHIFTED : [u8; 2usize] = [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 :
@@ -2769,13 +2735,12 @@ 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 : { 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::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 :
             vec![(JsonTerminalClasses::TermClass5,
             ::rusty_lr::parser::state::ShiftTarget::new(55, false)),
@@ -2802,15 +2767,14 @@ 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 : { 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(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)),
             (JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(56, false)),
@@ -2835,15 +2799,14 @@ 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 : { 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(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)),
             (JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(57, false)),
@@ -2868,15 +2831,14 @@ 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 : { 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(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)),
             (JsonTerminalClasses::TermClass6,
             ::rusty_lr::parser::state::ShiftTarget::new(58, false)),
@@ -2901,20 +2863,19 @@ 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 : { 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 : {
-            static __RULES : [u8; 1usize] = [27,]; static __SHIFTED : [u8; 1usize] =
-            [5,]; __RULES.iter().zip(__SHIFTED.iter()).map(| (& rule, & shifted) | {
+            ::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 : { 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 : {
@@ -3007,19 +2968,17 @@ impl JsonParser {
             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 : { 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, reduce_rules
-            .clone()))); __reduce_map.into_iter().collect() }, ruleset : { static __RULES
-            : [u8; 1usize] = [16,]; static __SHIFTED : [u8; 1usize] = [3,]; __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,
+            reduce_rules.clone()))); __reduce_map.into_iter().collect() }, ruleset : {
+            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,
@@ -3072,14 +3031,12 @@ impl JsonParser {
             ::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 : { 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,
+            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,
             ::rusty_lr::parser::state::ShiftTarget::new(1, false)),
             (JsonTerminalClasses::TermClass1,
             ::rusty_lr::parser::state::ShiftTarget::new(2, false)),],
@@ -3138,24 +3095,22 @@ 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 : { 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::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 :
             vec![(JsonTerminalClasses::TermClass14,
             ::rusty_lr::parser::state::ShiftTarget::new(26, false)),
             (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 : { static __RULES : [u8; 4usize] = [34,
-            35, 92, 93,]; static __SHIFTED : [u8; 4usize] = [1, 1, 0, 0,]; __RULES.iter()
+            ::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 {
@@ -3212,21 +3167,20 @@ impl JsonParser {
             (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 : { static __RULES : [u8; 3usize] = [8, 13,
-            16,]; static __SHIFTED : [u8; 3usize] = [2, 1, 0,]; __RULES.iter()
+            ::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 : { 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![], 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 : {
-            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,
@@ -3304,11 +3258,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(84, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, 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::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 : {
@@ -3374,11 +3327,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(89, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, 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::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 : {
@@ -3428,11 +3380,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(89, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, 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::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 : {
@@ -3520,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 : { 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::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,
@@ -3582,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 : { 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::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,
@@ -3628,11 +3577,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(103, true)),], reduce_map : { let
-            mut __reduce_map = std::collections::BTreeMap::new(); __reduce_map
-            .into_iter().collect() }, 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::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 : {
@@ -3712,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 : { 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::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,
@@ -3774,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 : { 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::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,
@@ -3820,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 : { 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::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() } },
         ];
