diff --git a/rusty_lr_core/src/parser/deterministic/context.rs b/rusty_lr_core/src/parser/deterministic/context.rs
index 7c844846..1abf5cda 100644
--- a/rusty_lr_core/src/parser/deterministic/context.rs
+++ b/rusty_lr_core/src/parser/deterministic/context.rs
@@ -70,8 +70,7 @@ impl<Data: DataStack, StateIndex: Index + Copy> Context<Data, StateIndex> {
     {
         self.feed_eof(parser, userdata)?;
 
-        // data_stack must be <Start> <EOF> in this point
-        self.data_stack.pop(); // pop eof
+        // data_stack must be <Start> in this point
         Ok(self.data_stack.pop_start().unwrap())
     }
 
@@ -514,10 +513,14 @@ impl<Data: DataStack, StateIndex: Index + Copy> Context<Data, StateIndex> {
             if next_state_id.push {
                 match term {
                     TerminalSymbol::Term(t) => self.data_stack.push_terminal(t),
-                    TerminalSymbol::Error | TerminalSymbol::Eof => self.data_stack.push_empty(),
+                    TerminalSymbol::Error => self.data_stack.push_empty(),
+                    TerminalSymbol::Eof => {} // do not push anything for eof
                 }
             } else {
-                self.data_stack.push_empty();
+                match term {
+                    TerminalSymbol::Term(_) | TerminalSymbol::Error => self.data_stack.push_empty(),
+                    TerminalSymbol::Eof => {} // do not push anything for eof
+                }
             }
 
             // location is `Some` if it is not `Eof`
diff --git a/rusty_lr_core/src/parser/nondeterministic/context.rs b/rusty_lr_core/src/parser/nondeterministic/context.rs
index f3603f48..588f2aba 100644
--- a/rusty_lr_core/src/parser/nondeterministic/context.rs
+++ b/rusty_lr_core/src/parser/nondeterministic/context.rs
@@ -531,7 +531,6 @@ impl<Data: DataStack, StateIndex: Index, const MAX_REDUCE_RULES: usize>
         let nodes = std::mem::take(&mut self.current_nodes);
         Ok(nodes.into_iter().map(move |node| {
             // let node = self.pop(eof_node).unwrap();
-            self.nodes_pool[node].data_stack.pop(); // pop eof
             self.nodes_pool[node].data_stack.pop_start().unwrap()
         }))
     }
@@ -1171,12 +1170,18 @@ impl<Data: DataStack, StateIndex: Index, const MAX_REDUCE_RULES: usize>
                         TerminalSymbol::Term(term) => {
                             node_.data_stack.push_terminal(term);
                         }
-                        TerminalSymbol::Eof | TerminalSymbol::Error => {
+                        TerminalSymbol::Error => {
                             node_.data_stack.push_empty();
                         }
+                        TerminalSymbol::Eof => {} // do not push for eof
                     }
                 } else {
-                    node_.data_stack.push_empty();
+                    match term {
+                        TerminalSymbol::Term(_) | TerminalSymbol::Error => {
+                            node_.data_stack.push_empty();
+                        }
+                        TerminalSymbol::Eof => {} // do not push for eof
+                    }
                 }
 
                 self.next_nodes.push(node);
@@ -1205,12 +1210,18 @@ impl<Data: DataStack, StateIndex: Index, const MAX_REDUCE_RULES: usize>
                     TerminalSymbol::Term(term) => {
                         node_.data_stack.push_terminal(term);
                     }
-                    TerminalSymbol::Eof | TerminalSymbol::Error => {
+                    TerminalSymbol::Error => {
                         node_.data_stack.push_empty();
                     }
+                    TerminalSymbol::Eof => {} // no push for eof
                 }
             } else {
-                node_.data_stack.push_empty();
+                match term {
+                    TerminalSymbol::Term(_) | TerminalSymbol::Error => {
+                        node_.data_stack.push_empty();
+                    }
+                    TerminalSymbol::Eof => {} // no push for eof
+                }
             }
 
             self.next_nodes.push(node);
diff --git a/rusty_lr_parser/src/emit.rs b/rusty_lr_parser/src/emit.rs
index f89715b9..7ccaa900 100644
--- a/rusty_lr_parser/src/emit.rs
+++ b/rusty_lr_parser/src/emit.rs
@@ -909,9 +909,9 @@ impl Grammar {
 
         // empty tag
         let empty_tag_name = format_ident!("Empty");
-
         // stack name for terminal symbol
         let terminal_stack_name = format_ident!("__terminals");
+
         // stack name for each non-terminal
         let mut stack_names_for_nonterm = Vec::with_capacity(self.nonterminals.len());
 
@@ -923,35 +923,50 @@ impl Grammar {
         // for consistent output
         let mut stack_names_in_order = Vec::new();
 
-        // insert stack for empty
-        ruletype_stack_map.insert("".to_string(), None);
+        let mut empty_tag_used = false;
+        let mut terminal_data_used = false;
 
         // insert stack for terminal token type
-        ruletype_stack_map.insert(
-            self.token_typename.to_string(),
-            Some(terminal_stack_name.clone()),
-        );
-        stack_names_in_order.push((terminal_stack_name.clone(), self.token_typename.clone()));
+        if self.terminal_classes.iter().any(|c| c.data_used) {
+            terminal_data_used = true;
+            ruletype_stack_map.insert(
+                self.token_typename.to_string(),
+                Some(terminal_stack_name.clone()),
+            );
+            stack_names_in_order.push((terminal_stack_name.clone(), self.token_typename.clone()));
+        }
+        if self.terminal_classes.iter().any(|c| !c.data_used) {
+            empty_tag_used = true;
+        }
 
         fn remove_whitespaces(s: String) -> String {
             s.chars().filter(|c| !c.is_whitespace()).collect()
         }
 
+        // iterates through nonterminals
         for nonterm in self.nonterminals.iter() {
-            let ruletype_stream = nonterm.ruletype.as_ref().cloned().unwrap_or_default();
-
-            let cur_len = ruletype_stack_map.len();
-            let stack_name = ruletype_stack_map
-                .entry(remove_whitespaces(ruletype_stream.to_string()))
-                .or_insert_with(|| {
-                    let new_stack_name = format_ident!("__stack{}", cur_len);
-                    stack_names_in_order.push((new_stack_name.clone(), ruletype_stream.clone()));
-                    Some(new_stack_name)
-                })
-                .clone();
-            stack_names_for_nonterm.push(stack_name);
+            if let Some(ruletype_stream) = nonterm.ruletype.as_ref().cloned() {
+                let cur_len = ruletype_stack_map.len();
+                let stack_name = ruletype_stack_map
+                    .entry(remove_whitespaces(ruletype_stream.to_string()))
+                    .or_insert_with(|| {
+                        let new_stack_name = format_ident!("__stack{}", cur_len);
+                        stack_names_in_order
+                            .push((new_stack_name.clone(), ruletype_stream.clone()));
+                        Some(new_stack_name)
+                    })
+                    .clone();
+                stack_names_for_nonterm.push(stack_name);
+            } else {
+                empty_tag_used = true;
+                stack_names_for_nonterm.push(None);
+            }
         }
 
+        // if only one tag kind was used, no need to emit tag_stack
+        let unique_tag = (empty_tag_used && stack_names_in_order.is_empty())
+            || (!empty_tag_used && stack_names_in_order.len() == 1);
+
         // Token -> Option<stack_name> map, `None` for empty
         let token_to_stack_name = |token: Token<TerminalSymbol<usize>, usize>| match token {
             Token::Term(term) => match term {
@@ -1116,13 +1131,15 @@ impl Grammar {
                             .or_insert_with(Vec::new)
                             .push(location_mapto);
 
-                        debug_tag_check_stream.extend(quote! {
-                            debug_assert!(
-                                __data_stack.#tag_stack_name.get(
-                                    __data_stack.#tag_stack_name.len()-1-#token_index_from_end
-                                ) == Some( &#tag_enum_name::#tag_name )
-                            );
-                        });
+                        if !unique_tag {
+                            debug_tag_check_stream.extend(quote! {
+                                debug_assert!(
+                                    __data_stack.#tag_stack_name.get(
+                                        __data_stack.#tag_stack_name.len()-1-#token_index_from_end
+                                    ) == Some( &#tag_enum_name::#tag_name )
+                                );
+                            });
+                        }
                     }
 
                     // new tag that will be inserted by this reduce action
@@ -1130,33 +1147,37 @@ impl Grammar {
                         .as_ref()
                         .unwrap_or(&empty_tag_name);
                     // pop n tokens from tag_stack and push new reduced tag
-                    let modify_tag_stream = if rule.tokens.len() > 0 {
-                        // if first token's tag is equal to new_tag, no need to (pop n tokens -> push new token).
-                        // just pop n-1 tokens
-                        let first_tag_name =
-                            token_to_stack_name(rule.tokens[0].token).unwrap_or(&empty_tag_name);
-
-                        if first_tag_name == new_tag_name {
-                            // pop n-1 tokens, no new insertion
-                            let len = rule.tokens.len() - 1;
-                            let truncate_stream = if len > 0 {
-                                quote! {__data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len);}
+                    let modify_tag_stream = if unique_tag {
+                        TokenStream::new()
+                    } else {
+                        if rule.tokens.len() > 0 {
+                            // if first token's tag is equal to new_tag, no need to (pop n tokens -> push new token).
+                            // just pop n-1 tokens
+                            let first_tag_name = token_to_stack_name(rule.tokens[0].token)
+                                .unwrap_or(&empty_tag_name);
+
+                            if first_tag_name == new_tag_name {
+                                // pop n-1 tokens, no new insertion
+                                let len = rule.tokens.len() - 1;
+                                let truncate_stream = if len > 0 {
+                                    quote! {__data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len);}
+                                } else {
+                                    TokenStream::new()
+                                };
+                                truncate_stream
                             } else {
-                                TokenStream::new()
-                            };
-                            truncate_stream
+                                let len = rule.tokens.len();
+                                // len > 0 here
+                                quote! {
+                                    __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len);
+                                    __data_stack.#tag_stack_name.push(#tag_enum_name::#new_tag_name);
+                                }
+                            }
                         } else {
-                            let len = rule.tokens.len();
-                            // len > 0 here
                             quote! {
-                                __data_stack.#tag_stack_name.truncate(__data_stack.#tag_stack_name.len() - #len);
                                 __data_stack.#tag_stack_name.push(#tag_enum_name::#new_tag_name);
                             }
                         }
-                    } else {
-                        quote! {
-                            __data_stack.#tag_stack_name.push(#tag_enum_name::#new_tag_name);
-                        }
                     };
 
                     let mut extract_data_stream = TokenStream::new();
@@ -1342,6 +1363,15 @@ impl Grammar {
 
         let start_idx = *self.nonterminals_index.get(&self.start_rule_name).unwrap();
         let start_stack_name = &stack_names_for_nonterm[start_idx];
+        let tag_name = start_stack_name.as_ref().unwrap_or(&empty_tag_name);
+        let tag_check_stream = if unique_tag {
+            TokenStream::new()
+        } else {
+            quote! {
+                let tag = self.#tag_stack_name.pop();
+                debug_assert!(tag == Some(#tag_enum_name::#tag_name));
+            }
+        };
         let (start_typename, pop_start) = match start_stack_name {
             Some(stack_name) => {
                 let ruletype = self.nonterminals[start_idx]
@@ -1349,11 +1379,11 @@ impl Grammar {
                     .as_ref()
                     .unwrap()
                     .clone();
+
                 (
                     ruletype,
                     quote! {
-                        let tag = self.#tag_stack_name.pop();
-                        debug_assert!(tag == Some(#tag_enum_name::#stack_name));
+                        #tag_check_stream
                         self.#stack_name.pop()
                     },
                 )
@@ -1361,20 +1391,12 @@ impl Grammar {
             None => (
                 quote! {()},
                 quote! {
-                    let tag = self.#tag_stack_name.pop();
-                    debug_assert!(tag == Some(#tag_enum_name::#empty_tag_name));
+                    #tag_check_stream
                     Some(())
                 },
             ),
         };
 
-        let mut tag_definition_stream = TokenStream::new();
-        for (stack_name, _) in &stack_names_in_order {
-            tag_definition_stream.extend(quote! {
-                #stack_name,
-            });
-        }
-
         // typename for count the number of tokens in each production rule
         let max_shift = self
             .nonterminals
@@ -1401,13 +1423,10 @@ impl Grammar {
 
         let mut stack_definition_stream = TokenStream::new();
         let mut stack_default_stream = TokenStream::new();
-        let mut pop_match_stream = TokenStream::new();
+        let mut pop_body_stream = TokenStream::new();
         let mut stack_clear_stream = TokenStream::new();
         let mut stack_append_stream = TokenStream::new();
         let stack_len = stack_names_in_order.len();
-        let split_off_count_init_stream = quote! {
-            let mut __counts: [#shift_typename; #stack_len+1] = [0; #stack_len+1];
-        };
         let mut split_off_split_stream = TokenStream::new();
         let mut split_off_ctor_stream = TokenStream::new();
         for (stack_idx, (stack_name, typename)) in stack_names_in_order.iter().enumerate() {
@@ -1417,9 +1436,15 @@ impl Grammar {
             stack_default_stream.extend(quote! {
                 #stack_name: Vec::new(),
             });
-            pop_match_stream.extend(quote! {
-                #tag_enum_name::#stack_name => { self.#stack_name.pop(); }
-            });
+            if unique_tag {
+                pop_body_stream.extend(quote! {
+                    self.#stack_name.pop();
+                });
+            } else {
+                pop_body_stream.extend(quote! {
+                    #tag_enum_name::#stack_name => { self.#stack_name.pop(); }
+                });
+            };
             stack_clear_stream.extend(quote! {
                 self.#stack_name.clear();
             });
@@ -1428,41 +1453,159 @@ impl Grammar {
             });
 
             let other_stack_name = format_ident!("__other_{}", stack_name);
-            split_off_split_stream.extend(quote! {
-                let #other_stack_name = self.#stack_name.split_off( self.#stack_name.len() - (__counts[#stack_idx] as usize) );
-            });
+            if unique_tag {
+                split_off_split_stream.extend(quote! {
+                    let #other_stack_name = self.#stack_name.split_off( at );
+                });
+            } else {
+                split_off_split_stream.extend(quote! {
+                    let #other_stack_name = self.#stack_name.split_off( self.#stack_name.len() - (__counts[#stack_idx] as usize) );
+                });
+            };
             split_off_ctor_stream.extend(quote! {
                 #stack_name: #other_stack_name,
             });
         }
 
+        let pop_stream = if unique_tag {
+            pop_body_stream
+        } else {
+            quote! {
+                match self.#tag_stack_name.pop().unwrap() {
+                    #pop_body_stream
+                    _ => {}
+                }
+            }
+        };
+
+        let split_off_count_stream = if unique_tag {
+            quote! {}
+        } else {
+            quote! {
+                let mut __counts: [#shift_typename; #stack_len+1] = [0; #stack_len+1];
+                let __other_tag_stack = self.#tag_stack_name.split_off(at);
+                for &tag in &__other_tag_stack {
+                    __counts[ tag as usize ] += 1;
+                }
+            }
+        };
+        if !unique_tag {
+            split_off_ctor_stream.extend(quote! {
+                #tag_stack_name: __other_tag_stack,
+            });
+        }
+
         let derive_clone_for_glr = if self.glr {
             quote! {#[derive(Clone)]}
         } else {
             quote! {}
         };
 
+        let push_terminal_body_stream = if terminal_data_used {
+            if unique_tag {
+                quote! {
+                    self.#terminal_stack_name.push( term );
+                }
+            } else {
+                quote! {
+                    self.#tag_stack_name.push(#tag_enum_name::#terminal_stack_name);
+                    self.#terminal_stack_name.push( term );
+                }
+            }
+        } else {
+            quote! {
+                unreachable!();
+            }
+        };
+        let push_empty_body_stream = if empty_tag_used {
+            if unique_tag {
+                TokenStream::new()
+            } else {
+                quote! {
+                    self.#tag_stack_name.push(#tag_enum_name::#empty_tag_name);
+                }
+            }
+        } else {
+            quote! { unreachable!(); }
+        };
+
+        let tag_definition_stream = if unique_tag {
+            TokenStream::new()
+        } else {
+            let mut tag_definition_body_stream = TokenStream::new();
+            for (stack_name, _) in &stack_names_in_order {
+                tag_definition_body_stream.extend(quote! {
+                    #stack_name,
+                });
+            }
+            if empty_tag_used {
+                tag_definition_body_stream.extend(quote! {
+                    #empty_tag_name,
+                });
+            }
+            quote! {
+                /// tag for token that represents which stack a token is using
+                #[allow(unused_braces, unused_parens, non_snake_case, non_camel_case_types)]
+                #[derive(Clone, Copy, PartialEq, Eq)]
+                pub enum #tag_enum_name {
+                    #tag_definition_body_stream
+                }
+            }
+        };
+
+        let tag_stack_definition_stream = if unique_tag {
+            TokenStream::new()
+        } else {
+            quote! { pub #tag_stack_name: Vec<#tag_enum_name>, }
+        };
+        let tag_stack_init_stream = if unique_tag {
+            TokenStream::new()
+        } else {
+            quote! {
+                #tag_stack_name: Vec::new(),
+            }
+        };
+
+        let tag_stack_clear_stream = if unique_tag {
+            TokenStream::new()
+        } else {
+            quote! {
+                self.#tag_stack_name.clear();
+            }
+        };
+
+        let tag_stack_reserve_stream = if unique_tag {
+            TokenStream::new()
+        } else {
+            quote! {
+                self.#tag_stack_name.reserve(additional);
+            }
+        };
+
+        let tag_stack_append_stream = if unique_tag {
+            TokenStream::new()
+        } else {
+            quote! {
+                self.#tag_stack_name.append(&mut other.#tag_stack_name);
+            }
+        };
+
         stream.extend(quote! {
-        /// tag for token that represents which stack a token is using
-        #[allow(unused_braces, unused_parens, non_snake_case, non_camel_case_types)]
-        #[derive(Clone, Copy, PartialEq, Eq)]
-        pub enum #tag_enum_name {
-            #tag_definition_stream
-            #empty_tag_name,
-        }
+
+        #tag_definition_stream
 
         /// enum for each non-terminal and terminal symbol, that actually hold data
         #[allow(unused_braces, unused_parens, non_snake_case, non_camel_case_types)]
         #derive_clone_for_glr
         pub struct #data_stack_typename {
-            pub #tag_stack_name: Vec<#tag_enum_name>,
+            #tag_stack_definition_stream
             #stack_definition_stream
         }
 
         impl Default for #data_stack_typename {
             fn default() -> Self {
                 Self {
-                    #tag_stack_name: Vec::new(),
+                    #tag_stack_init_stream
                     #stack_default_stream
                 }
             }
@@ -1487,42 +1630,32 @@ impl Grammar {
                 #pop_start
             }
             fn pop(&mut self) {
-                match self.#tag_stack_name.pop().unwrap() {
-                    #pop_match_stream
-                    _ => {}
-                }
+                #pop_stream
             }
             fn push_terminal(&mut self, term: Self::Term) {
-                self.#tag_stack_name.push(#tag_enum_name::#terminal_stack_name);
-                self.#terminal_stack_name.push( term );
+                #push_terminal_body_stream
             }
             fn push_empty(&mut self) {
-                self.#tag_stack_name.push(#tag_enum_name::#empty_tag_name);
+                #push_empty_body_stream
             }
 
             fn clear(&mut self) {
-                self.#tag_stack_name.clear();
+                #tag_stack_clear_stream
                 #stack_clear_stream
             }
             fn reserve(&mut self, additional: usize) {
-                self.#tag_stack_name.reserve(additional);
+                #tag_stack_reserve_stream
             }
 
             fn split_off(&mut self, at: usize) -> Self {
-                let __other_tag_stack = self.#tag_stack_name.split_off(at);
-
-                #split_off_count_init_stream
-                for &tag in &__other_tag_stack {
-                    __counts[ tag as usize ] += 1;
-                }
+                #split_off_count_stream
                 #split_off_split_stream
                 Self {
-                    #tag_stack_name: __other_tag_stack,
                     #split_off_ctor_stream
                 }
             }
             fn append(&mut self, other: &mut Self) {
-                self.#tag_stack_name.append(&mut other.#tag_stack_name);
+                #tag_stack_append_stream
                 #stack_append_stream
             }
 
diff --git a/rusty_lr_parser/src/parser/parser_expanded.rs b/rusty_lr_parser/src/parser/parser_expanded.rs
index cef8ba8e..e17794d9 100644
--- a/rusty_lr_parser/src/parser/parser_expanded.rs
+++ b/rusty_lr_parser/src/parser/parser_expanded.rs
@@ -616,6 +616,7 @@ impl ::rusty_lr_core::parser::nonterminal::NonTerminal for GrammarNonTerminals {
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum GrammarTags {
     __terminals,
+    __stack1,
     __stack2,
     __stack3,
     __stack4,
@@ -633,7 +634,6 @@ pub enum GrammarTags {
     __stack16,
     __stack17,
     __stack18,
-    __stack19,
     Empty,
 }
 /// enum for each non-terminal and terminal symbol, that actually hold data
@@ -641,30 +641,31 @@ pub enum GrammarTags {
 pub struct GrammarDataStack {
     pub __tags: Vec<GrammarTags>,
     __terminals: Vec<Lexed>,
-    __stack2: Vec<RuleDefArgs>,
-    __stack3: Vec<Option<Group>>,
-    __stack4: Vec<Vec<RuleLineArgs>>,
-    __stack5: Vec<RuleLineArgs>,
-    __stack6: Vec<PrecDPrecArgs>,
-    __stack7: Vec<(Option<Ident>, PatternArgs)>,
-    __stack8: Vec<TerminalSetItem>,
-    __stack9: Vec<TerminalSet>,
-    __stack10: Vec<PatternArgs>,
-    __stack11: Vec<IdentOrLiteral>,
-    __stack12: Vec<Vec<(Option<Ident>, PatternArgs)>>,
-    __stack13: Vec<Vec<PrecDPrecArgs>>,
-    __stack14: Vec<Option<Lexed>>,
-    __stack15: Vec<Vec<TerminalSetItem>>,
-    __stack16: Vec<Vec<PatternArgs>>,
-    __stack17: Vec<Vec<Vec<PatternArgs>>>,
-    __stack18: Vec<Vec<Lexed>>,
-    __stack19: Vec<Vec<IdentOrLiteral>>,
+    __stack1: Vec<RuleDefArgs>,
+    __stack2: Vec<Option<Group>>,
+    __stack3: Vec<Vec<RuleLineArgs>>,
+    __stack4: Vec<RuleLineArgs>,
+    __stack5: Vec<PrecDPrecArgs>,
+    __stack6: Vec<(Option<Ident>, PatternArgs)>,
+    __stack7: Vec<TerminalSetItem>,
+    __stack8: Vec<TerminalSet>,
+    __stack9: Vec<PatternArgs>,
+    __stack10: Vec<IdentOrLiteral>,
+    __stack11: Vec<Vec<(Option<Ident>, PatternArgs)>>,
+    __stack12: Vec<Vec<PrecDPrecArgs>>,
+    __stack13: Vec<Option<Lexed>>,
+    __stack14: Vec<Vec<TerminalSetItem>>,
+    __stack15: Vec<Vec<PatternArgs>>,
+    __stack16: Vec<Vec<Vec<PatternArgs>>>,
+    __stack17: Vec<Vec<Lexed>>,
+    __stack18: Vec<Vec<IdentOrLiteral>>,
 }
 impl Default for GrammarDataStack {
     fn default() -> Self {
         Self {
             __tags: Vec::new(),
             __terminals: Vec::new(),
+            __stack1: Vec::new(),
             __stack2: Vec::new(),
             __stack3: Vec::new(),
             __stack4: Vec::new(),
@@ -682,7 +683,6 @@ impl Default for GrammarDataStack {
             __stack16: Vec::new(),
             __stack17: Vec::new(),
             __stack18: Vec::new(),
-            __stack19: Vec::new(),
         }
     }
 }
@@ -726,7 +726,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack4)
+                GrammarTags::__stack3)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -734,7 +734,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                GrammarTags::__stack3)
+                GrammarTags::__stack2)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
@@ -742,9 +742,9 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 5usize);
-        __data_stack.__tags.push(GrammarTags::__stack2);
-        let mut RuleType = __data_stack.__stack3.pop().unwrap();
-        let mut RuleLines = __data_stack.__stack4.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack1);
+        let mut RuleType = __data_stack.__stack2.pop().unwrap();
+        let mut RuleLines = __data_stack.__stack3.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
@@ -764,7 +764,7 @@ impl GrammarDataStack {
                 rule_lines: RuleLines,
             }
         };
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
     ///RuleType -> parengroup
@@ -785,7 +785,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack3);
+        __data_stack.__tags.push(GrammarTags::__stack2);
         let mut parengroup = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -794,7 +794,7 @@ impl GrammarDataStack {
             };
             Some(group)
         };
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///RuleType ->
@@ -808,9 +808,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack3);
+        __data_stack.__tags.push(GrammarTags::__stack2);
         let __res = { None };
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///RuleLines -> RuleLines pipe RuleLine
@@ -827,7 +827,7 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack5)
+                GrammarTags::__stack4)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -835,12 +835,12 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack4)
+                GrammarTags::__stack3)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        let mut RuleLines = __data_stack.__stack4.pop().unwrap();
-        let mut RuleLine = __data_stack.__stack5.pop().unwrap();
+        let mut RuleLines = __data_stack.__stack3.pop().unwrap();
+        let mut RuleLine = __data_stack.__stack4.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         __location_stack.truncate(__location_stack.len() - 1usize);
         let mut __rustylr_location_pipe = __location_stack.pop().unwrap();
@@ -850,7 +850,7 @@ impl GrammarDataStack {
             RuleLines.push(RuleLine);
             RuleLines
         };
-        __data_stack.__stack4.push(__res);
+        __data_stack.__stack3.push(__res);
         Ok(true)
     }
     ///RuleLines -> RuleLine
@@ -867,15 +867,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack5)
+                GrammarTags::__stack4)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack4);
-        let mut RuleLine = __data_stack.__stack5.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack3);
+        let mut RuleLine = __data_stack.__stack4.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![RuleLine] };
-        __data_stack.__stack4.push(__res);
+        __data_stack.__stack3.push(__res);
         Ok(true)
     }
     ///RuleLine -> TokenMapped* PrecDef* Action
@@ -892,22 +892,22 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack3)
+                GrammarTags::__stack2)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack13)
+                GrammarTags::__stack12)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack12)
+                GrammarTags::__stack11)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack5);
-        let mut TokenMapped = __data_stack.__stack12.pop().unwrap();
-        let mut PrecDef = __data_stack.__stack13.pop().unwrap();
-        let mut Action = __data_stack.__stack3.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack4);
+        let mut TokenMapped = __data_stack.__stack11.pop().unwrap();
+        let mut PrecDef = __data_stack.__stack12.pop().unwrap();
+        let mut Action = __data_stack.__stack2.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = {
             RuleLineArgs {
@@ -919,7 +919,7 @@ impl GrammarDataStack {
                 dprec: None,
             }
         };
-        __data_stack.__stack5.push(__res);
+        __data_stack.__stack4.push(__res);
         Ok(true)
     }
     ///PrecDef -> percent prec IdentOrLiteral
@@ -936,7 +936,7 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack11)
+                GrammarTags::__stack10)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -948,12 +948,12 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack6);
-        let mut IdentOrLiteral = __data_stack.__stack11.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack5);
+        let mut IdentOrLiteral = __data_stack.__stack10.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = { PrecDPrecArgs::Prec(IdentOrLiteral) };
-        __data_stack.__stack6.push(__res);
+        __data_stack.__stack5.push(__res);
         Ok(true)
     }
     ///PrecDef -> percent prec error
@@ -982,7 +982,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack6);
+        __data_stack.__tags.push(GrammarTags::__stack5);
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         let mut __rustylr_location_error = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
@@ -996,7 +996,7 @@ impl GrammarDataStack {
                 });
             PrecDPrecArgs::None
         };
-        __data_stack.__stack6.push(__res);
+        __data_stack.__stack5.push(__res);
         Ok(true)
     }
     ///PrecDef -> percent dprec literal
@@ -1025,7 +1025,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack6);
+        __data_stack.__tags.push(GrammarTags::__stack5);
         let mut literal = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 3usize);
@@ -1035,7 +1035,7 @@ impl GrammarDataStack {
             };
             PrecDPrecArgs::DPrec(literal)
         };
-        __data_stack.__stack6.push(__res);
+        __data_stack.__stack5.push(__res);
         Ok(true)
     }
     ///PrecDef -> percent dprec error
@@ -1064,7 +1064,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack6);
+        __data_stack.__tags.push(GrammarTags::__stack5);
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         let mut __rustylr_location_error = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
@@ -1078,7 +1078,7 @@ impl GrammarDataStack {
                 });
             PrecDPrecArgs::None
         };
-        __data_stack.__stack6.push(__res);
+        __data_stack.__stack5.push(__res);
         Ok(true)
     }
     ///PrecDef -> percent error
@@ -1103,7 +1103,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        __data_stack.__tags.push(GrammarTags::__stack6);
+        __data_stack.__tags.push(GrammarTags::__stack5);
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut __rustylr_location_error = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
@@ -1117,7 +1117,7 @@ impl GrammarDataStack {
                 });
             PrecDPrecArgs::None
         };
-        __data_stack.__stack6.push(__res);
+        __data_stack.__stack5.push(__res);
         Ok(true)
     }
     ///TokenMapped -> Pattern
@@ -1134,15 +1134,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack7);
-        let mut Pattern = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack6);
+        let mut Pattern = __data_stack.__stack9.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { (None, Pattern) };
-        __data_stack.__stack7.push(__res);
+        __data_stack.__stack6.push(__res);
         Ok(true)
     }
     ///TokenMapped -> ident equal Pattern
@@ -1159,7 +1159,7 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -1171,8 +1171,8 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack7);
-        let mut Pattern = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack6);
+        let mut Pattern = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
@@ -1182,7 +1182,7 @@ impl GrammarDataStack {
             };
             (Some(ident), Pattern)
         };
-        __data_stack.__stack7.push(__res);
+        __data_stack.__stack6.push(__res);
         Ok(true)
     }
     ///TerminalSetItem -> ident
@@ -1203,7 +1203,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack8);
+        __data_stack.__tags.push(GrammarTags::__stack7);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -1212,7 +1212,7 @@ impl GrammarDataStack {
             };
             TerminalSetItem::Terminal(ident)
         };
-        __data_stack.__stack8.push(__res);
+        __data_stack.__stack7.push(__res);
         Ok(true)
     }
     ///TerminalSetItem -> ident minus ident
@@ -1241,7 +1241,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack8);
+        __data_stack.__tags.push(GrammarTags::__stack7);
         let mut last = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut first = __data_stack.__terminals.pop().unwrap();
@@ -1255,7 +1255,7 @@ impl GrammarDataStack {
             };
             TerminalSetItem::Range(first, last)
         };
-        __data_stack.__stack8.push(__res);
+        __data_stack.__stack7.push(__res);
         Ok(true)
     }
     ///TerminalSetItem -> ident minus error
@@ -1284,7 +1284,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack8);
+        __data_stack.__tags.push(GrammarTags::__stack7);
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         let mut __rustylr_location_error = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
@@ -1298,7 +1298,7 @@ impl GrammarDataStack {
                 });
             TerminalSetItem::Terminal(format_ident!("dummy"))
         };
-        __data_stack.__stack8.push(__res);
+        __data_stack.__stack7.push(__res);
         Ok(true)
     }
     ///TerminalSetItem -> literal
@@ -1319,7 +1319,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack8);
+        __data_stack.__tags.push(GrammarTags::__stack7);
         let mut literal = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -1328,7 +1328,7 @@ impl GrammarDataStack {
             };
             TerminalSetItem::Literal(literal)
         };
-        __data_stack.__stack8.push(__res);
+        __data_stack.__stack7.push(__res);
         Ok(true)
     }
     ///TerminalSetItem -> literal minus literal
@@ -1357,7 +1357,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack8);
+        __data_stack.__tags.push(GrammarTags::__stack7);
         let mut last = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut first = __data_stack.__terminals.pop().unwrap();
@@ -1371,7 +1371,7 @@ impl GrammarDataStack {
             };
             TerminalSetItem::LiteralRange(first, last)
         };
-        __data_stack.__stack8.push(__res);
+        __data_stack.__stack7.push(__res);
         Ok(true)
     }
     ///TerminalSetItem -> literal minus error
@@ -1400,7 +1400,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack8);
+        __data_stack.__tags.push(GrammarTags::__stack7);
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         let mut __rustylr_location_error = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
@@ -1414,7 +1414,7 @@ impl GrammarDataStack {
                 });
             TerminalSetItem::Terminal(format_ident!("dummy"))
         };
-        __data_stack.__stack8.push(__res);
+        __data_stack.__stack7.push(__res);
         Ok(true)
     }
     ///TerminalSet -> lbracket caret? TerminalSetItem* rbracket
@@ -1435,11 +1435,11 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack15)
+                GrammarTags::__stack14)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack14)
+                GrammarTags::__stack13)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
@@ -1447,9 +1447,9 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
-        __data_stack.__tags.push(GrammarTags::__stack9);
-        let mut caret = __data_stack.__stack14.pop().unwrap();
-        let mut TerminalSetItem = __data_stack.__stack15.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack8);
+        let mut caret = __data_stack.__stack13.pop().unwrap();
+        let mut TerminalSetItem = __data_stack.__stack14.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         let mut __rustylr_location_rbracket = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
@@ -1462,7 +1462,7 @@ impl GrammarDataStack {
                 close_span: __rustylr_location_rbracket.span(),
             }
         };
-        __data_stack.__stack9.push(__res);
+        __data_stack.__stack8.push(__res);
         Ok(true)
     }
     ///TerminalSet -> dot
@@ -1483,7 +1483,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack9);
+        __data_stack.__tags.push(GrammarTags::__stack8);
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut __rustylr_location_dot = __location_stack.pop().unwrap();
         let __res = {
@@ -1495,7 +1495,7 @@ impl GrammarDataStack {
                 close_span: span,
             }
         };
-        __data_stack.__stack9.push(__res);
+        __data_stack.__stack8.push(__res);
         Ok(true)
     }
     ///Pattern -> ident
@@ -1516,7 +1516,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
+        __data_stack.__tags.push(GrammarTags::__stack9);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -1525,7 +1525,7 @@ impl GrammarDataStack {
             };
             PatternArgs::Ident(ident)
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> Pattern plus
@@ -1546,11 +1546,11 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Pattern = __data_stack.__stack10.pop().unwrap();
+        let mut Pattern = __data_stack.__stack9.pop().unwrap();
         let mut plus = __data_stack.__terminals.pop().unwrap();
         let mut __rustylr_location_plus = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
@@ -1560,7 +1560,7 @@ impl GrammarDataStack {
             };
             PatternArgs::Plus(Box::new(Pattern), __rustylr_location_plus.span())
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> Pattern star
@@ -1581,18 +1581,18 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Pattern = __data_stack.__stack10.pop().unwrap();
+        let mut Pattern = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut __rustylr_location_star = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
             PatternArgs::Star(Box::new(Pattern), __rustylr_location_star.span())
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> Pattern question
@@ -1613,18 +1613,18 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Pattern = __data_stack.__stack10.pop().unwrap();
+        let mut Pattern = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut __rustylr_location_question = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
             PatternArgs::Question(Box::new(Pattern), __rustylr_location_question.span())
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> Pattern exclamation
@@ -1645,11 +1645,11 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Pattern = __data_stack.__stack10.pop().unwrap();
+        let mut Pattern = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         let mut __rustylr_location_exclamation = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
@@ -1659,7 +1659,7 @@ impl GrammarDataStack {
                 __rustylr_location_exclamation.span(),
             )
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> TerminalSet
@@ -1676,15 +1676,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack9)
+                GrammarTags::__stack8)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
-        let mut TerminalSet = __data_stack.__stack9.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack9);
+        let mut TerminalSet = __data_stack.__stack8.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { PatternArgs::TerminalSet(TerminalSet) };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> Pattern slash Pattern
@@ -1701,7 +1701,7 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -1709,16 +1709,16 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        let mut lh = __data_stack.__stack10.pop().unwrap();
-        let mut p1 = __data_stack.__stack10.pop().unwrap();
+        let mut lh = __data_stack.__stack9.pop().unwrap();
+        let mut p1 = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = { PatternArgs::Lookaheads(Box::new(p1), Box::new(lh)) };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> lparen $sep(Pattern*, pipe, +) rparen
@@ -1739,7 +1739,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack17)
+                GrammarTags::__stack16)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -1747,8 +1747,8 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
-        let mut Pattern = __data_stack.__stack17.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack9);
+        let mut Pattern = __data_stack.__stack16.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         let mut __rustylr_location_rparen = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
@@ -1760,7 +1760,7 @@ impl GrammarDataStack {
                 __rustylr_location_rparen.span(),
             )
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> lparen error rparen
@@ -1789,7 +1789,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
+        __data_stack.__tags.push(GrammarTags::__stack9);
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 1usize);
         let mut __rustylr_location_error = __location_stack.pop().unwrap();
@@ -1804,7 +1804,7 @@ impl GrammarDataStack {
                 });
             PatternArgs::Ident(format_ident!("dummy"))
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> literal
@@ -1825,7 +1825,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
+        __data_stack.__tags.push(GrammarTags::__stack9);
         let mut literal = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -1834,7 +1834,7 @@ impl GrammarDataStack {
             };
             PatternArgs::Literal(literal)
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> Pattern minus Pattern
@@ -1851,7 +1851,7 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -1859,16 +1859,16 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        let mut p2 = __data_stack.__stack10.pop().unwrap();
-        let mut p1 = __data_stack.__stack10.pop().unwrap();
+        let mut p2 = __data_stack.__stack9.pop().unwrap();
+        let mut p1 = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = { PatternArgs::Minus(Box::new(p1), Box::new(p2)) };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> dollar ident lparen Pattern comma Pattern comma? rparen
@@ -1893,7 +1893,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
@@ -1901,7 +1901,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 5usize) == Some(&
@@ -1917,9 +1917,9 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 8usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
-        let mut del = __data_stack.__stack10.pop().unwrap();
-        let mut base = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack9);
+        let mut del = __data_stack.__stack9.pop().unwrap();
+        let mut base = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 3usize);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
@@ -1941,7 +1941,7 @@ impl GrammarDataStack {
             }
             PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0)
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> dollar ident lparen Pattern comma Pattern comma plus rparen
@@ -1970,7 +1970,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
@@ -1978,7 +1978,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 5usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 6usize) == Some(&
@@ -1994,9 +1994,9 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 9usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
-        let mut del = __data_stack.__stack10.pop().unwrap();
-        let mut base = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack9);
+        let mut del = __data_stack.__stack9.pop().unwrap();
+        let mut base = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 5usize);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
@@ -2018,7 +2018,7 @@ impl GrammarDataStack {
             }
             PatternArgs::Sep(Box::new(base), Box::new(del), true, *__rustylr_location0)
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> dollar ident lparen Pattern comma Pattern comma star rparen
@@ -2047,7 +2047,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
@@ -2055,7 +2055,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 5usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 6usize) == Some(&
@@ -2071,9 +2071,9 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 9usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
-        let mut del = __data_stack.__stack10.pop().unwrap();
-        let mut base = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack9);
+        let mut del = __data_stack.__stack9.pop().unwrap();
+        let mut base = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 5usize);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
@@ -2095,7 +2095,7 @@ impl GrammarDataStack {
             }
             PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0)
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> dollar ident lparen Pattern comma Pattern error rparen
@@ -2120,7 +2120,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
@@ -2128,7 +2128,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 5usize) == Some(&
@@ -2144,9 +2144,9 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 8usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
-        let mut del = __data_stack.__stack10.pop().unwrap();
-        let mut base = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack9);
+        let mut del = __data_stack.__stack9.pop().unwrap();
+        let mut base = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 3usize);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
@@ -2177,7 +2177,7 @@ impl GrammarDataStack {
                 });
             PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0)
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Pattern -> dollar ident lparen Pattern comma Pattern comma error rparen
@@ -2206,7 +2206,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
@@ -2214,7 +2214,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 5usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 6usize) == Some(&
@@ -2230,9 +2230,9 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 9usize);
-        __data_stack.__tags.push(GrammarTags::__stack10);
-        let mut del = __data_stack.__stack10.pop().unwrap();
-        let mut base = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack9);
+        let mut del = __data_stack.__stack9.pop().unwrap();
+        let mut base = __data_stack.__stack9.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 4usize);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
@@ -2263,7 +2263,7 @@ impl GrammarDataStack {
                 });
             PatternArgs::Sep(Box::new(base), Box::new(del), false, *__rustylr_location0)
         };
-        __data_stack.__stack10.push(__res);
+        __data_stack.__stack9.push(__res);
         Ok(true)
     }
     ///Action -> bracegroup
@@ -2284,7 +2284,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack3);
+        __data_stack.__tags.push(GrammarTags::__stack2);
         let mut bracegroup = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -2293,7 +2293,7 @@ impl GrammarDataStack {
             };
             Some(group)
         };
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///Action ->
@@ -2307,9 +2307,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack3);
+        __data_stack.__tags.push(GrammarTags::__stack2);
         let __res = { None };
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///IdentOrLiteral -> ident
@@ -2330,7 +2330,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack11);
+        __data_stack.__tags.push(GrammarTags::__stack10);
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -2339,7 +2339,7 @@ impl GrammarDataStack {
             };
             IdentOrLiteral::Ident(ident)
         };
-        __data_stack.__stack11.push(__res);
+        __data_stack.__stack10.push(__res);
         Ok(true)
     }
     ///IdentOrLiteral -> literal
@@ -2360,7 +2360,7 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack11);
+        __data_stack.__tags.push(GrammarTags::__stack10);
         let mut literal = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -2369,7 +2369,7 @@ impl GrammarDataStack {
             };
             IdentOrLiteral::Literal(literal)
         };
-        __data_stack.__stack11.push(__res);
+        __data_stack.__stack10.push(__res);
         Ok(true)
     }
     ///Directive -> percent token ident [^semicolon]+ semicolon
@@ -2390,7 +2390,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -2407,7 +2407,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 5usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut __rustylr_data_3 = __data_stack.__stack18.pop().unwrap();
+        let mut __rustylr_data_3 = __data_stack.__stack17.pop().unwrap();
         let mut ident = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 5usize);
@@ -2623,7 +2623,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -2636,7 +2636,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut __rustylr_data_2 = __data_stack.__stack18.pop().unwrap();
+        let mut __rustylr_data_2 = __data_stack.__stack17.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 2usize);
         let mut __rustylr_location_tokentype = __location_stack.pop().unwrap();
@@ -2712,7 +2712,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -2725,7 +2725,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut __rustylr_data_2 = __data_stack.__stack18.pop().unwrap();
+        let mut __rustylr_data_2 = __data_stack.__stack17.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 2usize);
         let mut __rustylr_location_userdata = __location_stack.pop().unwrap();
@@ -2801,7 +2801,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack19)
+                GrammarTags::__stack18)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -2814,7 +2814,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut IdentOrLiteral = __data_stack.__stack19.pop().unwrap();
+        let mut IdentOrLiteral = __data_stack.__stack18.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 2usize);
         let mut __rustylr_location_left = __location_stack.pop().unwrap();
@@ -2893,7 +2893,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack19)
+                GrammarTags::__stack18)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -2906,7 +2906,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut IdentOrLiteral = __data_stack.__stack19.pop().unwrap();
+        let mut IdentOrLiteral = __data_stack.__stack18.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 2usize);
         let mut __rustylr_location_right = __location_stack.pop().unwrap();
@@ -2985,7 +2985,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack19)
+                GrammarTags::__stack18)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -2998,7 +2998,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut IdentOrLiteral = __data_stack.__stack19.pop().unwrap();
+        let mut IdentOrLiteral = __data_stack.__stack18.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 2usize);
         let mut __rustylr_location_precedence = __location_stack.pop().unwrap();
@@ -3073,7 +3073,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -3086,7 +3086,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut __rustylr_data_2 = __data_stack.__stack18.pop().unwrap();
+        let mut __rustylr_data_2 = __data_stack.__stack17.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 2usize);
         let mut __rustylr_location_errortype = __location_stack.pop().unwrap();
@@ -3162,7 +3162,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -3175,7 +3175,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut __rustylr_data_2 = __data_stack.__stack18.pop().unwrap();
+        let mut __rustylr_data_2 = __data_stack.__stack17.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 2usize);
         let mut __rustylr_location_moduleprefix = __location_stack.pop().unwrap();
@@ -3574,7 +3574,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -3587,7 +3587,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut ident = __data_stack.__stack18.pop().unwrap();
+        let mut ident = __data_stack.__stack17.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 4usize);
         {
@@ -3667,7 +3667,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -3680,7 +3680,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut __rustylr_data_2 = __data_stack.__stack18.pop().unwrap();
+        let mut __rustylr_data_2 = __data_stack.__stack17.pop().unwrap();
         let mut filter = __data_stack.__terminals.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         __location_stack.truncate(__location_stack.len() - 4usize);
@@ -3755,7 +3755,7 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -3768,7 +3768,7 @@ impl GrammarDataStack {
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut __rustylr_data_2 = __data_stack.__stack18.pop().unwrap();
+        let mut __rustylr_data_2 = __data_stack.__stack17.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 2usize);
         __location_stack.truncate(__location_stack.len() - 4usize);
         let __rustylr_data_2 = Self::custom_reduce_action_0(
@@ -3880,12 +3880,12 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack2)
+                GrammarTags::__stack1)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
         __data_stack.__tags.push(GrammarTags::Empty);
-        let mut Rule = __data_stack.__stack2.pop().unwrap();
+        let mut Rule = __data_stack.__stack1.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         {
             data.rules.push(Rule);
@@ -3906,15 +3906,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack7)
+                GrammarTags::__stack6)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack12);
-        let mut A = __data_stack.__stack7.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack11);
+        let mut A = __data_stack.__stack6.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack12.push(__res);
+        __data_stack.__stack11.push(__res);
         Ok(true)
     }
     ///TokenMapped+ -> TokenMapped+ TokenMapped
@@ -3931,22 +3931,22 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack7)
+                GrammarTags::__stack6)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack12)
+                GrammarTags::__stack11)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Ap = __data_stack.__stack12.pop().unwrap();
-        let mut A = __data_stack.__stack7.pop().unwrap();
+        let mut Ap = __data_stack.__stack11.pop().unwrap();
+        let mut A = __data_stack.__stack6.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack12.push(__res);
+        __data_stack.__stack11.push(__res);
         Ok(true)
     }
     ///TokenMapped* -> TokenMapped+
@@ -3963,13 +3963,13 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack12)
+                GrammarTags::__stack11)
             );
         }
-        let mut __token0 = __data_stack.__stack12.pop().unwrap();
+        let mut __token0 = __data_stack.__stack11.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = __token0;
-        __data_stack.__stack12.push(__res);
+        __data_stack.__stack11.push(__res);
         Ok(true)
     }
     ///TokenMapped* ->
@@ -3983,9 +3983,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack12);
+        __data_stack.__tags.push(GrammarTags::__stack11);
         let __res = { vec![] };
-        __data_stack.__stack12.push(__res);
+        __data_stack.__stack11.push(__res);
         Ok(true)
     }
     ///PrecDef+ -> PrecDef
@@ -4002,15 +4002,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack6)
+                GrammarTags::__stack5)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack13);
-        let mut A = __data_stack.__stack6.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack12);
+        let mut A = __data_stack.__stack5.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack13.push(__res);
+        __data_stack.__stack12.push(__res);
         Ok(true)
     }
     ///PrecDef+ -> PrecDef+ PrecDef
@@ -4027,22 +4027,22 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack6)
+                GrammarTags::__stack5)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack13)
+                GrammarTags::__stack12)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Ap = __data_stack.__stack13.pop().unwrap();
-        let mut A = __data_stack.__stack6.pop().unwrap();
+        let mut Ap = __data_stack.__stack12.pop().unwrap();
+        let mut A = __data_stack.__stack5.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack13.push(__res);
+        __data_stack.__stack12.push(__res);
         Ok(true)
     }
     ///PrecDef* -> PrecDef+
@@ -4059,13 +4059,13 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack13)
+                GrammarTags::__stack12)
             );
         }
-        let mut __token0 = __data_stack.__stack13.pop().unwrap();
+        let mut __token0 = __data_stack.__stack12.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = __token0;
-        __data_stack.__stack13.push(__res);
+        __data_stack.__stack12.push(__res);
         Ok(true)
     }
     ///PrecDef* ->
@@ -4079,9 +4079,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack13);
+        __data_stack.__tags.push(GrammarTags::__stack12);
         let __res = { vec![] };
-        __data_stack.__stack13.push(__res);
+        __data_stack.__stack12.push(__res);
         Ok(true)
     }
     ///caret? -> caret
@@ -4102,11 +4102,11 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack14);
+        __data_stack.__tags.push(GrammarTags::__stack13);
         let mut A = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = Some(A);
-        __data_stack.__stack14.push(__res);
+        __data_stack.__stack13.push(__res);
         Ok(true)
     }
     ///caret? ->
@@ -4120,9 +4120,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack14);
+        __data_stack.__tags.push(GrammarTags::__stack13);
         let __res = { None };
-        __data_stack.__stack14.push(__res);
+        __data_stack.__stack13.push(__res);
         Ok(true)
     }
     ///TerminalSetItem+ -> TerminalSetItem
@@ -4139,15 +4139,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack8)
+                GrammarTags::__stack7)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack15);
-        let mut A = __data_stack.__stack8.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack14);
+        let mut A = __data_stack.__stack7.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack15.push(__res);
+        __data_stack.__stack14.push(__res);
         Ok(true)
     }
     ///TerminalSetItem+ -> TerminalSetItem+ TerminalSetItem
@@ -4164,22 +4164,22 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack8)
+                GrammarTags::__stack7)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack15)
+                GrammarTags::__stack14)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Ap = __data_stack.__stack15.pop().unwrap();
-        let mut A = __data_stack.__stack8.pop().unwrap();
+        let mut Ap = __data_stack.__stack14.pop().unwrap();
+        let mut A = __data_stack.__stack7.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack15.push(__res);
+        __data_stack.__stack14.push(__res);
         Ok(true)
     }
     ///TerminalSetItem* -> TerminalSetItem+
@@ -4196,13 +4196,13 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack15)
+                GrammarTags::__stack14)
             );
         }
-        let mut __token0 = __data_stack.__stack15.pop().unwrap();
+        let mut __token0 = __data_stack.__stack14.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = __token0;
-        __data_stack.__stack15.push(__res);
+        __data_stack.__stack14.push(__res);
         Ok(true)
     }
     ///TerminalSetItem* ->
@@ -4216,9 +4216,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack15);
+        __data_stack.__tags.push(GrammarTags::__stack14);
         let __res = { vec![] };
-        __data_stack.__stack15.push(__res);
+        __data_stack.__stack14.push(__res);
         Ok(true)
     }
     ///Pattern+ -> Pattern
@@ -4235,15 +4235,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack16);
-        let mut A = __data_stack.__stack10.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack15);
+        let mut A = __data_stack.__stack9.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack16.push(__res);
+        __data_stack.__stack15.push(__res);
         Ok(true)
     }
     ///Pattern+ -> Pattern+ Pattern
@@ -4260,22 +4260,22 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack10)
+                GrammarTags::__stack9)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack16)
+                GrammarTags::__stack15)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut A = __data_stack.__stack10.pop().unwrap();
-        let mut Ap = __data_stack.__stack16.pop().unwrap();
+        let mut Ap = __data_stack.__stack15.pop().unwrap();
+        let mut A = __data_stack.__stack9.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack16.push(__res);
+        __data_stack.__stack15.push(__res);
         Ok(true)
     }
     ///Pattern* -> Pattern+
@@ -4292,13 +4292,13 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack16)
+                GrammarTags::__stack15)
             );
         }
-        let mut __token0 = __data_stack.__stack16.pop().unwrap();
+        let mut __token0 = __data_stack.__stack15.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = __token0;
-        __data_stack.__stack16.push(__res);
+        __data_stack.__stack15.push(__res);
         Ok(true)
     }
     ///Pattern* ->
@@ -4312,9 +4312,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack16);
+        __data_stack.__tags.push(GrammarTags::__stack15);
         let __res = { vec![] };
-        __data_stack.__stack16.push(__res);
+        __data_stack.__stack15.push(__res);
         Ok(true)
     }
     ///$sep(Pattern*, pipe, +) -> Pattern*
@@ -4331,15 +4331,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack16)
+                GrammarTags::__stack15)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack17);
-        let mut __token0 = __data_stack.__stack16.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack16);
+        let mut __token0 = __data_stack.__stack15.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![__token0] };
-        __data_stack.__stack17.push(__res);
+        __data_stack.__stack16.push(__res);
         Ok(true)
     }
     ///$sep(Pattern*, pipe, +) -> $sep(Pattern*, pipe, +) pipe Pattern*
@@ -4356,7 +4356,7 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack16)
+                GrammarTags::__stack15)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -4364,19 +4364,19 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                GrammarTags::__stack17)
+                GrammarTags::__stack16)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        let mut __token1 = __data_stack.__stack16.pop().unwrap();
-        let mut __token0 = __data_stack.__stack17.pop().unwrap();
+        let mut __token1 = __data_stack.__stack15.pop().unwrap();
+        let mut __token0 = __data_stack.__stack16.pop().unwrap();
         __data_stack.__terminals.truncate(__data_stack.__terminals.len() - 1usize);
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = {
             __token0.push(__token1);
             __token0
         };
-        __data_stack.__stack17.push(__res);
+        __data_stack.__stack16.push(__res);
         Ok(true)
     }
     ///comma? -> comma
@@ -4434,11 +4434,11 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack18);
+        __data_stack.__tags.push(GrammarTags::__stack17);
         let mut A = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack18.push(__res);
+        __data_stack.__stack17.push(__res);
         Ok(true)
     }
     ///[^semicolon]+ -> [^semicolon]+ [^semicolon]
@@ -4459,18 +4459,18 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Ap = __data_stack.__stack18.pop().unwrap();
+        let mut Ap = __data_stack.__stack17.pop().unwrap();
         let mut A = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack18.push(__res);
+        __data_stack.__stack17.push(__res);
         Ok(true)
     }
     ///IdentOrLiteral+ -> IdentOrLiteral
@@ -4487,15 +4487,15 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack11)
+                GrammarTags::__stack10)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack19);
-        let mut A = __data_stack.__stack11.pop().unwrap();
+        __data_stack.__tags.push(GrammarTags::__stack18);
+        let mut A = __data_stack.__stack10.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack19.push(__res);
+        __data_stack.__stack18.push(__res);
         Ok(true)
     }
     ///IdentOrLiteral+ -> IdentOrLiteral+ IdentOrLiteral
@@ -4512,22 +4512,22 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack11)
+                GrammarTags::__stack10)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack19)
+                GrammarTags::__stack18)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut A = __data_stack.__stack11.pop().unwrap();
-        let mut Ap = __data_stack.__stack19.pop().unwrap();
+        let mut A = __data_stack.__stack10.pop().unwrap();
+        let mut Ap = __data_stack.__stack18.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack19.push(__res);
+        __data_stack.__stack18.push(__res);
         Ok(true)
     }
     ///ident+ -> ident
@@ -4548,11 +4548,11 @@ impl GrammarDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(GrammarTags::__stack18);
+        __data_stack.__tags.push(GrammarTags::__stack17);
         let mut A = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack18.push(__res);
+        __data_stack.__stack17.push(__res);
         Ok(true)
     }
     ///ident+ -> ident+ ident
@@ -4573,18 +4573,18 @@ impl GrammarDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Ap = __data_stack.__stack18.pop().unwrap();
+        let mut Ap = __data_stack.__stack17.pop().unwrap();
         let mut A = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack18.push(__res);
+        __data_stack.__stack17.push(__res);
         Ok(true)
     }
     ///ident* -> ident+
@@ -4601,13 +4601,13 @@ impl GrammarDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                GrammarTags::__stack18)
+                GrammarTags::__stack17)
             );
         }
-        let mut __token0 = __data_stack.__stack18.pop().unwrap();
+        let mut __token0 = __data_stack.__stack17.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = __token0;
-        __data_stack.__stack18.push(__res);
+        __data_stack.__stack17.push(__res);
         Ok(true)
     }
     ///ident* ->
@@ -4621,9 +4621,9 @@ impl GrammarDataStack {
         __rustylr_location0: &mut SpanPair,
     ) -> Result<bool, ::rusty_lr_core::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(GrammarTags::__stack18);
+        __data_stack.__tags.push(GrammarTags::__stack17);
         let __res = { vec![] };
-        __data_stack.__stack18.push(__res);
+        __data_stack.__stack17.push(__res);
         Ok(true)
     }
     ///GrammarLine+ -> GrammarLine
@@ -4696,6 +4696,9 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack {
             GrammarTags::__terminals => {
                 self.__terminals.pop();
             }
+            GrammarTags::__stack1 => {
+                self.__stack1.pop();
+            }
             GrammarTags::__stack2 => {
                 self.__stack2.pop();
             }
@@ -4747,9 +4750,6 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack {
             GrammarTags::__stack18 => {
                 self.__stack18.pop();
             }
-            GrammarTags::__stack19 => {
-                self.__stack19.pop();
-            }
             _ => {}
         }
     }
@@ -4763,6 +4763,7 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack {
     fn clear(&mut self) {
         self.__tags.clear();
         self.__terminals.clear();
+        self.__stack1.clear();
         self.__stack2.clear();
         self.__stack3.clear();
         self.__stack4.clear();
@@ -4780,77 +4781,76 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack {
         self.__stack16.clear();
         self.__stack17.clear();
         self.__stack18.clear();
-        self.__stack19.clear();
     }
     fn reserve(&mut self, additional: usize) {
         self.__tags.reserve(additional);
     }
     fn split_off(&mut self, at: usize) -> Self {
-        let __other_tag_stack = self.__tags.split_off(at);
         let mut __counts: [u8; 19usize + 1] = [0; 19usize + 1];
+        let __other_tag_stack = self.__tags.split_off(at);
         for &tag in &__other_tag_stack {
             __counts[tag as usize] += 1;
         }
         let __other___terminals = self
             .__terminals
             .split_off(self.__terminals.len() - (__counts[0usize] as usize));
+        let __other___stack1 = self
+            .__stack1
+            .split_off(self.__stack1.len() - (__counts[1usize] as usize));
         let __other___stack2 = self
             .__stack2
-            .split_off(self.__stack2.len() - (__counts[1usize] as usize));
+            .split_off(self.__stack2.len() - (__counts[2usize] as usize));
         let __other___stack3 = self
             .__stack3
-            .split_off(self.__stack3.len() - (__counts[2usize] as usize));
+            .split_off(self.__stack3.len() - (__counts[3usize] as usize));
         let __other___stack4 = self
             .__stack4
-            .split_off(self.__stack4.len() - (__counts[3usize] as usize));
+            .split_off(self.__stack4.len() - (__counts[4usize] as usize));
         let __other___stack5 = self
             .__stack5
-            .split_off(self.__stack5.len() - (__counts[4usize] as usize));
+            .split_off(self.__stack5.len() - (__counts[5usize] as usize));
         let __other___stack6 = self
             .__stack6
-            .split_off(self.__stack6.len() - (__counts[5usize] as usize));
+            .split_off(self.__stack6.len() - (__counts[6usize] as usize));
         let __other___stack7 = self
             .__stack7
-            .split_off(self.__stack7.len() - (__counts[6usize] as usize));
+            .split_off(self.__stack7.len() - (__counts[7usize] as usize));
         let __other___stack8 = self
             .__stack8
-            .split_off(self.__stack8.len() - (__counts[7usize] as usize));
+            .split_off(self.__stack8.len() - (__counts[8usize] as usize));
         let __other___stack9 = self
             .__stack9
-            .split_off(self.__stack9.len() - (__counts[8usize] as usize));
+            .split_off(self.__stack9.len() - (__counts[9usize] as usize));
         let __other___stack10 = self
             .__stack10
-            .split_off(self.__stack10.len() - (__counts[9usize] as usize));
+            .split_off(self.__stack10.len() - (__counts[10usize] as usize));
         let __other___stack11 = self
             .__stack11
-            .split_off(self.__stack11.len() - (__counts[10usize] as usize));
+            .split_off(self.__stack11.len() - (__counts[11usize] as usize));
         let __other___stack12 = self
             .__stack12
-            .split_off(self.__stack12.len() - (__counts[11usize] as usize));
+            .split_off(self.__stack12.len() - (__counts[12usize] as usize));
         let __other___stack13 = self
             .__stack13
-            .split_off(self.__stack13.len() - (__counts[12usize] as usize));
+            .split_off(self.__stack13.len() - (__counts[13usize] as usize));
         let __other___stack14 = self
             .__stack14
-            .split_off(self.__stack14.len() - (__counts[13usize] as usize));
+            .split_off(self.__stack14.len() - (__counts[14usize] as usize));
         let __other___stack15 = self
             .__stack15
-            .split_off(self.__stack15.len() - (__counts[14usize] as usize));
+            .split_off(self.__stack15.len() - (__counts[15usize] as usize));
         let __other___stack16 = self
             .__stack16
-            .split_off(self.__stack16.len() - (__counts[15usize] as usize));
+            .split_off(self.__stack16.len() - (__counts[16usize] as usize));
         let __other___stack17 = self
             .__stack17
-            .split_off(self.__stack17.len() - (__counts[16usize] as usize));
+            .split_off(self.__stack17.len() - (__counts[17usize] as usize));
         let __other___stack18 = self
             .__stack18
-            .split_off(self.__stack18.len() - (__counts[17usize] as usize));
-        let __other___stack19 = self
-            .__stack19
-            .split_off(self.__stack19.len() - (__counts[18usize] as usize));
+            .split_off(self.__stack18.len() - (__counts[18usize] as usize));
         Self {
-            __tags: __other_tag_stack,
             __terminals: __other___terminals,
+            __stack1: __other___stack1,
             __stack2: __other___stack2,
             __stack3: __other___stack3,
             __stack4: __other___stack4,
@@ -4868,12 +4868,13 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack {
             __stack16: __other___stack16,
             __stack17: __other___stack17,
             __stack18: __other___stack18,
-            __stack19: __other___stack19,
+            __tags: __other_tag_stack,
         }
     }
     fn append(&mut self, other: &mut Self) {
         self.__tags.append(&mut other.__tags);
         self.__terminals.append(&mut other.__terminals);
+        self.__stack1.append(&mut other.__stack1);
         self.__stack2.append(&mut other.__stack2);
         self.__stack3.append(&mut other.__stack3);
         self.__stack4.append(&mut other.__stack4);
@@ -4891,7 +4892,6 @@ impl ::rusty_lr_core::parser::data_stack::DataStack for GrammarDataStack {
         self.__stack16.append(&mut other.__stack16);
         self.__stack17.append(&mut other.__stack17);
         self.__stack18.append(&mut other.__stack18);
-        self.__stack19.append(&mut other.__stack19);
     }
     fn reduce_action(
         data_stack: &mut Self,
diff --git a/scripts/diff/calculator.rs b/scripts/diff/calculator.rs
index d22f8231..b7c398e4 100644
--- a/scripts/diff/calculator.rs
+++ b/scripts/diff/calculator.rs
@@ -198,7 +198,7 @@ impl ::rusty_lr::parser::nonterminal::NonTerminal for ENonTerminals {
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum ETags {
     __terminals,
-    __stack2,
+    __stack1,
     Empty,
 }
 /// enum for each non-terminal and terminal symbol, that actually hold data
@@ -206,14 +206,14 @@ pub enum ETags {
 pub struct EDataStack {
     pub __tags: Vec<ETags>,
     __terminals: Vec<Token>,
-    __stack2: Vec<i32>,
+    __stack1: Vec<i32>,
 }
 impl Default for EDataStack {
     fn default() -> Self {
         Self {
             __tags: Vec::new(),
             __terminals: Vec::new(),
-            __stack2: Vec::new(),
+            __stack1: Vec::new(),
         }
     }
 }
@@ -247,7 +247,7 @@ impl EDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -255,12 +255,12 @@ impl EDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        let mut a2 = __data_stack.__stack2.pop().unwrap();
-        let mut A = __data_stack.__stack2.pop().unwrap();
+        let mut a2 = __data_stack.__stack1.pop().unwrap();
+        let mut A = __data_stack.__stack1.pop().unwrap();
         let mut plus = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = {
@@ -268,7 +268,7 @@ impl EDataStack {
             *data += 1;
             A + a2
         };
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
     ///A -> M
@@ -285,13 +285,13 @@ impl EDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
         }
-        let mut M = __data_stack.__stack2.pop().unwrap();
+        let mut M = __data_stack.__stack1.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = M;
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
     ///M -> M star M
@@ -308,7 +308,7 @@ impl EDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -316,12 +316,12 @@ impl EDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        let mut __rustylr_data_2 = __data_stack.__stack2.pop().unwrap();
-        let mut __rustylr_data_0 = __data_stack.__stack2.pop().unwrap();
+        let mut __rustylr_data_2 = __data_stack.__stack1.pop().unwrap();
+        let mut __rustylr_data_0 = __data_stack.__stack1.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __rustylr_data_0 = Self::custom_reduce_action_0(
             __rustylr_data_0,
@@ -336,7 +336,7 @@ impl EDataStack {
         )?;
         let mut m2 = __rustylr_data_2;
         let __res = { M_optim * m2 };
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
     ///P -> num
@@ -357,7 +357,7 @@ impl EDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(ETags::__stack2);
+        __data_stack.__tags.push(ETags::__stack1);
         let mut num = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = {
@@ -367,7 +367,7 @@ impl EDataStack {
                 return Err(format!("{:?}", num));
             }
         };
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
     ///P -> lparen E rparen
@@ -388,7 +388,7 @@ impl EDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -396,11 +396,11 @@ impl EDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(ETags::__stack2);
-        let mut E = __data_stack.__stack2.pop().unwrap();
+        __data_stack.__tags.push(ETags::__stack1);
+        let mut E = __data_stack.__stack1.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = E;
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
     ///E -> A
@@ -417,13 +417,13 @@ impl EDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
         }
-        let mut A = __data_stack.__stack2.pop().unwrap();
+        let mut A = __data_stack.__stack1.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = A;
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
 }
@@ -443,16 +443,16 @@ impl ::rusty_lr::parser::data_stack::DataStack for EDataStack {
     type Location = ::rusty_lr::DefaultLocation;
     fn pop_start(&mut self) -> Option<Self::StartType> {
         let tag = self.__tags.pop();
-        debug_assert!(tag == Some(ETags::__stack2));
-        self.__stack2.pop()
+        debug_assert!(tag == Some(ETags::__stack1));
+        self.__stack1.pop()
     }
     fn pop(&mut self) {
         match self.__tags.pop().unwrap() {
             ETags::__terminals => {
                 self.__terminals.pop();
             }
-            ETags::__stack2 => {
-                self.__stack2.pop();
+            ETags::__stack1 => {
+                self.__stack1.pop();
             }
             _ => {}
         }
@@ -467,33 +467,33 @@ impl ::rusty_lr::parser::data_stack::DataStack for EDataStack {
     fn clear(&mut self) {
         self.__tags.clear();
         self.__terminals.clear();
-        self.__stack2.clear();
+        self.__stack1.clear();
     }
     fn reserve(&mut self, additional: usize) {
         self.__tags.reserve(additional);
     }
     fn split_off(&mut self, at: usize) -> Self {
-        let __other_tag_stack = self.__tags.split_off(at);
         let mut __counts: [u8; 2usize + 1] = [0; 2usize + 1];
+        let __other_tag_stack = self.__tags.split_off(at);
         for &tag in &__other_tag_stack {
             __counts[tag as usize] += 1;
         }
         let __other___terminals = self
             .__terminals
             .split_off(self.__terminals.len() - (__counts[0usize] as usize));
-        let __other___stack2 = self
-            .__stack2
-            .split_off(self.__stack2.len() - (__counts[1usize] as usize));
+        let __other___stack1 = self
+            .__stack1
+            .split_off(self.__stack1.len() - (__counts[1usize] as usize));
         Self {
-            __tags: __other_tag_stack,
             __terminals: __other___terminals,
-            __stack2: __other___stack2,
+            __stack1: __other___stack1,
+            __tags: __other_tag_stack,
         }
     }
     fn append(&mut self, other: &mut Self) {
         self.__tags.append(&mut other.__tags);
         self.__terminals.append(&mut other.__terminals);
-        self.__stack2.append(&mut other.__stack2);
+        self.__stack1.append(&mut other.__stack1);
     }
     fn reduce_action(
         data_stack: &mut Self,
diff --git a/scripts/diff/calculator_u8.rs b/scripts/diff/calculator_u8.rs
index 815fa698..01e9ec2a 100644
--- a/scripts/diff/calculator_u8.rs
+++ b/scripts/diff/calculator_u8.rs
@@ -227,9 +227,9 @@ impl ::rusty_lr::parser::nonterminal::NonTerminal for ENonTerminals {
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum ETags {
     __terminals,
+    __stack1,
     __stack2,
     __stack3,
-    __stack4,
     Empty,
 }
 /// enum for each non-terminal and terminal symbol, that actually hold data
@@ -237,18 +237,18 @@ pub enum ETags {
 pub struct EDataStack {
     pub __tags: Vec<ETags>,
     __terminals: Vec<char>,
-    __stack2: Vec<i32>,
-    __stack3: Vec<f32>,
-    __stack4: Vec<Vec<char>>,
+    __stack1: Vec<i32>,
+    __stack2: Vec<f32>,
+    __stack3: Vec<Vec<char>>,
 }
 impl Default for EDataStack {
     fn default() -> Self {
         Self {
             __tags: Vec::new(),
             __terminals: Vec::new(),
+            __stack1: Vec::new(),
             __stack2: Vec::new(),
             __stack3: Vec::new(),
-            __stack4: Vec::new(),
         }
     }
 }
@@ -303,7 +303,7 @@ impl EDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                ETags::__stack4)
+                ETags::__stack3)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
@@ -311,11 +311,11 @@ impl EDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(ETags::__stack2);
-        let mut Digit = __data_stack.__stack4.pop().unwrap();
+        __data_stack.__tags.push(ETags::__stack1);
+        let mut Digit = __data_stack.__stack3.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = { Digit.into_iter().collect::<String>().parse().unwrap() };
-        __data_stack.__stack2.push(__res);
+        __data_stack.__stack1.push(__res);
         Ok(true)
     }
     ///P -> Number
@@ -332,15 +332,15 @@ impl EDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                ETags::__stack2)
+                ETags::__stack1)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(ETags::__stack3);
-        let mut Number = __data_stack.__stack2.pop().unwrap();
+        __data_stack.__tags.push(ETags::__stack2);
+        let mut Number = __data_stack.__stack1.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { Number as f32 };
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///P -> ' '* '(' E ')' ' '*
@@ -365,7 +365,7 @@ impl EDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                ETags::__stack3)
+                ETags::__stack2)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
@@ -377,11 +377,11 @@ impl EDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 5usize);
-        __data_stack.__tags.push(ETags::__stack3);
-        let mut E = __data_stack.__stack3.pop().unwrap();
+        __data_stack.__tags.push(ETags::__stack2);
+        let mut E = __data_stack.__stack2.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 5usize);
         let __res = E;
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///E -> E Op E
@@ -398,7 +398,7 @@ impl EDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                ETags::__stack3)
+                ETags::__stack2)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -406,12 +406,12 @@ impl EDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                ETags::__stack3)
+                ETags::__stack2)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
-        let mut e2 = __data_stack.__stack3.pop().unwrap();
-        let mut E = __data_stack.__stack3.pop().unwrap();
+        let mut e2 = __data_stack.__stack2.pop().unwrap();
+        let mut E = __data_stack.__stack2.pop().unwrap();
         let mut Op = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = {
@@ -423,7 +423,7 @@ impl EDataStack {
                 _ => panic!("Unknown operator: {:?}", Op),
             }
         };
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///E -> ' '* '-' E
@@ -440,7 +440,7 @@ impl EDataStack {
         {
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                ETags::__stack3)
+                ETags::__stack2)
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
@@ -452,11 +452,11 @@ impl EDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
-        __data_stack.__tags.push(ETags::__stack3);
-        let mut E = __data_stack.__stack3.pop().unwrap();
+        __data_stack.__tags.push(ETags::__stack2);
+        let mut E = __data_stack.__stack2.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 3usize);
         let __res = { -E };
-        __data_stack.__stack3.push(__res);
+        __data_stack.__stack2.push(__res);
         Ok(true)
     }
     ///' '+ -> ' '+ ' '
@@ -536,11 +536,11 @@ impl EDataStack {
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        __data_stack.__tags.push(ETags::__stack4);
+        __data_stack.__tags.push(ETags::__stack3);
         let mut A = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
         let __res = { vec![A] };
-        __data_stack.__stack4.push(__res);
+        __data_stack.__stack3.push(__res);
         Ok(true)
     }
     ///Digit+ -> Digit+ Digit
@@ -561,18 +561,18 @@ impl EDataStack {
             );
             debug_assert!(
                 __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                ETags::__stack4)
+                ETags::__stack3)
             );
         }
         __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
-        let mut Ap = __data_stack.__stack4.pop().unwrap();
+        let mut Ap = __data_stack.__stack3.pop().unwrap();
         let mut A = __data_stack.__terminals.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 2usize);
         let __res = {
             Ap.push(A);
             Ap
         };
-        __data_stack.__stack4.push(__res);
+        __data_stack.__stack3.push(__res);
         Ok(true)
     }
 }
@@ -592,23 +592,23 @@ impl ::rusty_lr::parser::data_stack::DataStack for EDataStack {
     type Location = ::rusty_lr::DefaultLocation;
     fn pop_start(&mut self) -> Option<Self::StartType> {
         let tag = self.__tags.pop();
-        debug_assert!(tag == Some(ETags::__stack3));
-        self.__stack3.pop()
+        debug_assert!(tag == Some(ETags::__stack2));
+        self.__stack2.pop()
     }
     fn pop(&mut self) {
         match self.__tags.pop().unwrap() {
             ETags::__terminals => {
                 self.__terminals.pop();
             }
+            ETags::__stack1 => {
+                self.__stack1.pop();
+            }
             ETags::__stack2 => {
                 self.__stack2.pop();
             }
             ETags::__stack3 => {
                 self.__stack3.pop();
             }
-            ETags::__stack4 => {
-                self.__stack4.pop();
-            }
             _ => {}
         }
     }
@@ -622,45 +622,45 @@ impl ::rusty_lr::parser::data_stack::DataStack for EDataStack {
     fn clear(&mut self) {
         self.__tags.clear();
         self.__terminals.clear();
+        self.__stack1.clear();
         self.__stack2.clear();
         self.__stack3.clear();
-        self.__stack4.clear();
     }
     fn reserve(&mut self, additional: usize) {
         self.__tags.reserve(additional);
     }
     fn split_off(&mut self, at: usize) -> Self {
-        let __other_tag_stack = self.__tags.split_off(at);
         let mut __counts: [u8; 4usize + 1] = [0; 4usize + 1];
+        let __other_tag_stack = self.__tags.split_off(at);
         for &tag in &__other_tag_stack {
             __counts[tag as usize] += 1;
         }
         let __other___terminals = self
             .__terminals
             .split_off(self.__terminals.len() - (__counts[0usize] as usize));
+        let __other___stack1 = self
+            .__stack1
+            .split_off(self.__stack1.len() - (__counts[1usize] as usize));
         let __other___stack2 = self
             .__stack2
-            .split_off(self.__stack2.len() - (__counts[1usize] as usize));
+            .split_off(self.__stack2.len() - (__counts[2usize] as usize));
         let __other___stack3 = self
             .__stack3
-            .split_off(self.__stack3.len() - (__counts[2usize] as usize));
-        let __other___stack4 = self
-            .__stack4
-            .split_off(self.__stack4.len() - (__counts[3usize] as usize));
+            .split_off(self.__stack3.len() - (__counts[3usize] as usize));
         Self {
-            __tags: __other_tag_stack,
             __terminals: __other___terminals,
+            __stack1: __other___stack1,
             __stack2: __other___stack2,
             __stack3: __other___stack3,
-            __stack4: __other___stack4,
+            __tags: __other_tag_stack,
         }
     }
     fn append(&mut self, other: &mut Self) {
         self.__tags.append(&mut other.__tags);
         self.__terminals.append(&mut other.__terminals);
+        self.__stack1.append(&mut other.__stack1);
         self.__stack2.append(&mut other.__stack2);
         self.__stack3.append(&mut other.__stack3);
-        self.__stack4.append(&mut other.__stack4);
     }
     fn reduce_action(
         data_stack: &mut Self,
diff --git a/scripts/diff/json.rs b/scripts/diff/json.rs
index 771fe50b..3484ad99 100644
--- a/scripts/diff/json.rs
+++ b/scripts/diff/json.rs
@@ -497,25 +497,12 @@ impl ::rusty_lr::parser::nonterminal::NonTerminal for JsonNonTerminals {
         *self as usize
     }
 }
-/// tag for token that represents which stack a token is using
-#[allow(unused_braces, unused_parens, non_snake_case, non_camel_case_types)]
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum JsonTags {
-    __terminals,
-    Empty,
-}
 /// enum for each non-terminal and terminal symbol, that actually hold data
 #[allow(unused_braces, unused_parens, non_snake_case, non_camel_case_types)]
-pub struct JsonDataStack {
-    pub __tags: Vec<JsonTags>,
-    __terminals: Vec<char>,
-}
+pub struct JsonDataStack {}
 impl Default for JsonDataStack {
     fn default() -> Self {
-        Self {
-            __tags: Vec::new(),
-            __terminals: Vec::new(),
-        }
+        Self {}
     }
 }
 #[allow(
@@ -537,22 +524,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -566,22 +538,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -595,22 +552,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 1usize);
         let mut __rustylr_location_error = __location_stack.pop().unwrap();
         __location_stack.truncate(__location_stack.len() - 1usize);
@@ -631,13 +573,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 1usize);
         Ok(false)
     }
@@ -651,22 +587,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -680,30 +601,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 5usize);
         Ok(false)
     }
@@ -717,22 +615,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -746,22 +629,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -775,22 +643,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -804,18 +657,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -829,30 +671,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 5usize);
         Ok(false)
     }
@@ -866,22 +685,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -895,18 +699,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -920,18 +713,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -945,22 +727,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -974,22 +741,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -1003,22 +755,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -1032,18 +769,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -1057,18 +783,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -1082,26 +797,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 4usize);
         Ok(false)
     }
@@ -1115,30 +811,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 4usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 4usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 5usize);
         Ok(false)
     }
@@ -1152,26 +825,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 3usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 3usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 4usize);
         Ok(false)
     }
@@ -1185,13 +839,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 1usize);
         Ok(false)
     }
@@ -1205,22 +853,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 2usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 2usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 3usize);
         Ok(false)
     }
@@ -1235,7 +868,6 @@ impl JsonDataStack {
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(JsonTags::Empty);
         Ok(false)
     }
     ///Character+ -> Character
@@ -1248,13 +880,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 1usize);
         Ok(false)
     }
@@ -1268,18 +894,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -1294,7 +909,6 @@ impl JsonDataStack {
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(JsonTags::Empty);
         Ok(false)
     }
     ///Digit+ -> ['0'-'9']
@@ -1307,13 +921,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 1usize);
         Ok(false)
     }
@@ -1327,18 +935,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -1352,13 +949,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 1usize);
         Ok(false)
     }
@@ -1372,18 +963,7 @@ impl JsonDataStack {
         data: &mut (),
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
-        #[cfg(debug_assertions)]
-        {
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 0usize) == Some(&
-                JsonTags::Empty)
-            );
-            debug_assert!(
-                __data_stack.__tags.get(__data_stack.__tags.len() - 1 - 1usize) == Some(&
-                JsonTags::Empty)
-            );
-        }
-        __data_stack.__tags.truncate(__data_stack.__tags.len() - 1usize);
+        #[cfg(debug_assertions)] {}
         __location_stack.truncate(__location_stack.len() - 2usize);
         Ok(false)
     }
@@ -1398,7 +978,6 @@ impl JsonDataStack {
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(JsonTags::Empty);
         Ok(false)
     }
     ///"" ->
@@ -1412,7 +991,6 @@ impl JsonDataStack {
         __rustylr_location0: &mut std::ops::Range<usize>,
     ) -> Result<bool, ::rusty_lr::DefaultReduceActionError> {
         #[cfg(debug_assertions)] {}
-        __data_stack.__tags.push(JsonTags::Empty);
         Ok(false)
     }
 }
@@ -1431,50 +1009,19 @@ impl ::rusty_lr::parser::data_stack::DataStack for JsonDataStack {
     type StartType = ();
     type Location = std::ops::Range<usize>;
     fn pop_start(&mut self) -> Option<Self::StartType> {
-        let tag = self.__tags.pop();
-        debug_assert!(tag == Some(JsonTags::Empty));
         Some(())
     }
-    fn pop(&mut self) {
-        match self.__tags.pop().unwrap() {
-            JsonTags::__terminals => {
-                self.__terminals.pop();
-            }
-            _ => {}
-        }
-    }
+    fn pop(&mut self) {}
     fn push_terminal(&mut self, term: Self::Term) {
-        self.__tags.push(JsonTags::__terminals);
-        self.__terminals.push(term);
-    }
-    fn push_empty(&mut self) {
-        self.__tags.push(JsonTags::Empty);
-    }
-    fn clear(&mut self) {
-        self.__tags.clear();
-        self.__terminals.clear();
-    }
-    fn reserve(&mut self, additional: usize) {
-        self.__tags.reserve(additional);
+        unreachable!();
     }
+    fn push_empty(&mut self) {}
+    fn clear(&mut self) {}
+    fn reserve(&mut self, additional: usize) {}
     fn split_off(&mut self, at: usize) -> Self {
-        let __other_tag_stack = self.__tags.split_off(at);
-        let mut __counts: [u8; 1usize + 1] = [0; 1usize + 1];
-        for &tag in &__other_tag_stack {
-            __counts[tag as usize] += 1;
-        }
-        let __other___terminals = self
-            .__terminals
-            .split_off(self.__terminals.len() - (__counts[0usize] as usize));
-        Self {
-            __tags: __other_tag_stack,
-            __terminals: __other___terminals,
-        }
-    }
-    fn append(&mut self, other: &mut Self) {
-        self.__tags.append(&mut other.__tags);
-        self.__terminals.append(&mut other.__terminals);
+        Self {}
     }
+    fn append(&mut self, other: &mut Self) {}
     fn reduce_action(
         data_stack: &mut Self,
         location_stack: &mut Vec<std::ops::Range<usize>>,
