diff --git a/project.gyp b/project.gyp
index 1ebebb70..d4fa8b44 100644
--- a/project.gyp
+++ b/project.gyp
@@ -14,8 +14,6 @@
         'src/compiler/build_tables/build_parse_table.cc',
         'src/compiler/build_tables/build_tables.cc',
         'src/compiler/build_tables/does_match_any_line.cc',
-        'src/compiler/build_tables/get_completion_status.cc',
-        'src/compiler/build_tables/get_metadata.cc',
         'src/compiler/build_tables/item_set_closure.cc',
         'src/compiler/build_tables/lex_item.cc',
         'src/compiler/build_tables/lex_item_transitions.cc',
diff --git a/spec/compiler/build_tables/get_metadata_spec.cc b/spec/compiler/build_tables/get_metadata_spec.cc
deleted file mode 100644
index 6f962e75..00000000
--- a/spec/compiler/build_tables/get_metadata_spec.cc
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "compiler/compiler_spec_helper.h"
-#include "compiler/rules/metadata.h"
-#include "compiler/build_tables/get_metadata.h"
-
-using namespace rules;
-using namespace build_tables;
-
-START_TEST
-
-describe("get_metadata(rule, key)", []() {
-  MetadataKey key1 = MetadataKey(100);
-  MetadataKey key2 = MetadataKey(101);
-  rule_ptr rule;
-
-  describe("with a rule without the metadata key", [&]() {
-    it("returns the zero range", [&]() {
-      rule = sym("x");
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(0, 0)));
-
-      rule = seq({ sym("x"), sym("y") });
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(0, 0)));
-
-      rule = metadata(seq({ sym("x"), sym("y") }), {{key2, 5}});
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(0, 0)));
-    });
-  });
-
-  describe("when given a metadata rule", [&]() {
-    before_each([&]() {
-      rule = make_shared<Metadata>(sym("x"), map<MetadataKey, int>({
-        { key1, 1 },
-        { key2, 2 },
-      }));
-    });
-
-    it("returns the value for the given key", [&]() {
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(1, 1)));
-      AssertThat(get_metadata(rule, key2), Equals(MetadataRange(2, 2)));
-    });
-
-    it("returns 0 if the rule does not have the key", [&]() {
-      AssertThat(get_metadata(rule, MetadataKey(0)), Equals(MetadataRange(0, 0)));
-    });
-
-    describe("when the rule contains another metadata rule", [&]() {
-      it("also gets metadata from the inner metadata rule", [&]() {
-        rule = make_shared<Metadata>(make_shared<Metadata>(sym("x"), map<MetadataKey, int>({
-          { key1, 1 }
-        })), map<MetadataKey, int>());
-
-        AssertThat(get_metadata(rule, key1), Equals(MetadataRange(1, 1)));
-      });
-    });
-  });
-
-  describe("with a sequence starting with a metadata rule", [&]() {
-    it("returns the metadata rule's value for the key", [&]() {
-      rule = seq({
-        metadata(sym("x"), {{key1, 5}}),
-        sym("y")
-      });
-
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(5, 5)));
-    });
-  });
-
-  describe("with a sequence whose starting value can be blank", [&]() {
-    it("includes later elements of the sequence in the returned range", [&]() {
-      rule = seq({
-        repeat(metadata(sym("x"), {{key1, 3}})),
-        choice({ metadata(sym("x"), {{key1, 5}}), blank() }),
-        metadata(sym("x"), {{key1, 7}}),
-        metadata(sym("x"), {{key1, 9}}),
-      });
-
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(3, 7)));
-    });
-  });
-
-  describe("with a sequence whose starting value can be blank", [&]() {
-    it("includes later elements of the sequence in the returned range", [&]() {
-      rule = seq({
-        repeat(metadata(sym("x"), {{key1, 3}})),
-        choice({ metadata(sym("x"), {{key1, 5}}), blank() }),
-        metadata(sym("x"), {{key1, 7}}),
-        metadata(sym("x"), {{key1, 9}}),
-      });
-
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(3, 7)));
-    });
-  });
-
-  describe("with a choice rule", [&]() {
-    it("merges the ranges for the choices elements", [&]() {
-      rule = choice({
-        metadata(sym("a"), {{key1, 5}}),
-        metadata(sym("b"), {{key1, 3}}),
-        sym("c"),
-        metadata(sym("d"), {{key1, 1}}),
-      });
-
-      AssertThat(get_metadata(rule, key1), Equals(MetadataRange(1, 5)));
-    });
-  });
-});
-
-END_TEST
diff --git a/spec/compiler/build_tables/lex_conflict_manager_spec.cc b/spec/compiler/build_tables/lex_conflict_manager_spec.cc
index ab3c17b6..cd80b5a8 100644
--- a/spec/compiler/build_tables/lex_conflict_manager_spec.cc
+++ b/spec/compiler/build_tables/lex_conflict_manager_spec.cc
@@ -8,7 +8,7 @@ using namespace build_tables;
 
 START_TEST
 
-describe("LexConflictManager", []() {
+describe("LexConflictManager::resolve(new_action, old_action)", []() {
   LexicalGrammar lexical_grammar{{
     Variable("other_token", VariableTypeNamed, pattern("[a-b]")),
     Variable("lookahead_token", VariableTypeNamed, pattern("[c-d]"))
@@ -29,36 +29,58 @@ describe("LexConflictManager", []() {
     AssertThat(update, IsFalse());
   });
 
-  describe("accept-token/advance conflicts", [&]() {
-    it("prefers the advance", [&]() {
-      update = conflict_manager.resolve(LexAction::Advance(1, { 0, 0 }), LexAction::Accept(sym3, 3));
-      AssertThat(update, IsTrue());
-
-      update = conflict_manager.resolve(LexAction::Accept(sym3, 3), LexAction::Advance(1, { 0, 0 }));
-      AssertThat(update, IsFalse());
-    });
-  });
-
   describe("accept-token/accept-token conflicts", [&]() {
-    describe("when one token has a higher precedence than the other", [&]() {
-      it("prefers the token with the higher precedence", [&]() {
-        update = conflict_manager.resolve(LexAction::Accept(sym2, 0), LexAction::Accept(sym3, 2));
+    describe("when one tokens' precedence values differ", [&]() {
+      it("favors the token with higher precedence", [&]() {
+        update = conflict_manager.resolve(LexAction::Accept(sym2, 1, false), LexAction::Accept(sym1, 2, false));
         AssertThat(update, IsFalse());
 
-        update = conflict_manager.resolve(LexAction::Accept(sym3, 2), LexAction::Accept(sym2, 0));
+        update = conflict_manager.resolve(LexAction::Accept(sym1, 2, false), LexAction::Accept(sym2, 1, false));
         AssertThat(update, IsTrue());
       });
     });
 
-    describe("when both tokens have the same precedence", [&]() {
-      it("prefers the token listed earlier in the grammar", [&]() {
-        update = conflict_manager.resolve(LexAction::Accept(sym2, 0), LexAction::Accept(sym1, 0));
+    describe("when one token is string-based and the other is regexp-based", [&]() {
+      it("favors the string-based token", [&]() {
+        update = conflict_manager.resolve(LexAction::Accept(sym1, 0, false), LexAction::Accept(sym2, 0, true));
         AssertThat(update, IsFalse());
 
-        update = conflict_manager.resolve(LexAction::Accept(sym1, 0), LexAction::Accept(sym2, 0));
+        update = conflict_manager.resolve(LexAction::Accept(sym2, 0, true), LexAction::Accept(sym1, 0, false));
         AssertThat(update, IsTrue());
       });
     });
+
+    describe("when the tokens have equal precedence", [&]() {
+      it("favors the token listed earlier in the grammar", [&]() {
+        update = conflict_manager.resolve(LexAction::Accept(sym2, 0, false), LexAction::Accept(sym1, 0, false));
+        AssertThat(update, IsFalse());
+
+        update = conflict_manager.resolve(LexAction::Accept(sym1, 0, false), LexAction::Accept(sym2, 0, false));
+        AssertThat(update, IsTrue());
+      });
+    });
+  });
+
+  describe("advance/accept-token conflicts", [&]() {
+    describe("when the token to accept has higher precedence", [&]() {
+      it("prefers the accept-token action", [&]() {
+        update = conflict_manager.resolve(LexAction::Advance(1, { 1, 2 }), LexAction::Accept(sym3, 3, true));
+        AssertThat(update, IsFalse());
+
+        update = conflict_manager.resolve(LexAction::Accept(sym3, 3, true), LexAction::Advance(1, { 1, 2 }));
+        AssertThat(update, IsTrue());
+      });
+    });
+
+    describe("when the token to accept does not have a higher precedence", [&]() {
+      it("favors the advance action", [&]() {
+        update = conflict_manager.resolve(LexAction::Advance(1, { 1, 2 }), LexAction::Accept(sym3, 2, true));
+        AssertThat(update, IsTrue());
+
+        update = conflict_manager.resolve(LexAction::Accept(sym3, 2, true), LexAction::Advance(1, { 1, 2 }));
+        AssertThat(update, IsFalse());
+      });
+    });
   });
 });
 
diff --git a/spec/compiler/build_tables/lex_item_spec.cc b/spec/compiler/build_tables/lex_item_spec.cc
index db35b659..faa3aeb0 100644
--- a/spec/compiler/build_tables/lex_item_spec.cc
+++ b/spec/compiler/build_tables/lex_item_spec.cc
@@ -38,6 +38,29 @@ describe("LexItem", []() {
       });
     });
   });
+
+  describe("completion_status()", [&]() {
+    it("indicates whether the item is done, its precedence, and whether it is a string", [&]() {
+      LexItem item1(Symbol(0, true), character({ 'a', 'b', 'c' }));
+      AssertThat(item1.completion_status().is_done, IsFalse());
+      AssertThat(item1.completion_status().precedence, Equals(0));
+      AssertThat(item1.completion_status().is_string, IsFalse());
+
+      LexItem item2(Symbol(0, true), choice({
+        metadata(blank(), { {PRECEDENCE, 3}, {IS_STRING, 1} }),
+        character({ 'a', 'b', 'c' })
+      }));
+
+      AssertThat(item2.completion_status().is_done, IsTrue());
+      AssertThat(item2.completion_status().precedence, Equals(3));
+      AssertThat(item2.completion_status().is_string, IsTrue());
+
+      LexItem item3(Symbol(0, true), repeat(character({ ' ', '\t' })));
+      AssertThat(item3.completion_status().is_done, IsTrue());
+      AssertThat(item3.completion_status().precedence, Equals(0));
+      AssertThat(item3.completion_status().is_string, IsFalse());
+    });
+  });
 });
 
 describe("LexItemSet::transitions()", [&]() {
@@ -48,12 +71,15 @@ describe("LexItemSet::transitions()", [&]() {
 
     AssertThat(
       item_set.transitions(),
-      Equals(map<CharacterSet, LexItemSet>({
+      Equals(LexItemSet::TransitionMap({
         {
           CharacterSet().include('x'),
-          LexItemSet({
-            LexItem(Symbol(1), blank()),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), blank()),
+            }),
+            PrecedenceRange()
+          }
         }
       })));
   });
@@ -70,16 +96,77 @@ describe("LexItemSet::transitions()", [&]() {
 
     AssertThat(
       item_set.transitions(),
-      Equals(map<CharacterSet, LexItemSet>({
+      Equals(LexItemSet::TransitionMap({
         {
           CharacterSet().include('w'),
-          LexItemSet({
-            LexItem(Symbol(1), seq({
-              character({ 'x' }),
-              character({ 'y' }),
-              character({ 'z' }),
-            })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), seq({
+                character({ 'x' }),
+                character({ 'y' }),
+                character({ 'z' }),
+              })),
+            }),
+            PrecedenceRange()
+          }
+        }
+      })));
+  });
+
+  it("handles sequences with nested precedence", [&]() {
+    LexItemSet item_set({
+      LexItem(Symbol(1), seq({
+        prec(3, seq({
+          prec(4, seq({
+            character({ 'w' }),
+            character({ 'x' }) })),
+          character({ 'y' }) })),
+        character({ 'z' }),
+      })),
+    });
+
+    AssertThat(
+      item_set.transitions(),
+      Equals(LexItemSet::TransitionMap({
+        {
+          CharacterSet().include('w'),
+          {
+            LexItemSet({
+              LexItem(Symbol(1), seq({
+                prec(3, seq({
+                  prec(4, character({ 'x' })),
+                  character({ 'y' }) })),
+                character({ 'z' }),
+              })),
+            }),
+            PrecedenceRange(4)
+          }
+        }
+      })));
+
+    LexItemSet item_set2({
+      LexItem(Symbol(1), seq({
+        prec(3, seq({
+          prec(4, character({ 'x' })),
+          character({ 'y' }) })),
+        character({ 'z' }),
+      })),
+    });
+
+    AssertThat(
+      item_set2.transitions(),
+      Equals(LexItemSet::TransitionMap({
+        {
+          CharacterSet().include('x'),
+          {
+            LexItemSet({
+              LexItem(Symbol(1), seq({
+                prec(3, character({ 'y' })),
+                character({ 'z' }),
+              })),
+            }),
+            PrecedenceRange(3)
+          }
         }
       })));
   });
@@ -98,21 +185,27 @@ describe("LexItemSet::transitions()", [&]() {
 
     AssertThat(
       item_set.transitions(),
-      Equals(map<CharacterSet, LexItemSet>({
+      Equals(LexItemSet::TransitionMap({
         {
           CharacterSet().include('x'),
-          LexItemSet({
-            LexItem(Symbol(1), seq({
-              character({ 'y' }),
-              character({ 'z' }),
-            })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), seq({
+                character({ 'y' }),
+                character({ 'z' }),
+              })),
+            }),
+            PrecedenceRange()
+          }
         },
         {
           CharacterSet().include('y'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ 'z' })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), character({ 'z' })),
+            }),
+            PrecedenceRange()
+          }
         }
       })));
   });
@@ -136,26 +229,53 @@ describe("LexItemSet::transitions()", [&]() {
 
     AssertThat(
       item_set.transitions(),
-      Equals(map<CharacterSet, LexItemSet>({
+      Equals(LexItemSet::TransitionMap({
         {
           CharacterSet().include('a'),
-          LexItemSet({
-            LexItem(Symbol(1), seq({
-              character({ 'b' }),
-              repeat1(seq({
-                character({ 'a' }),
+          {
+            LexItemSet({
+              LexItem(Symbol(1), seq({
                 character({ 'b' }),
-              }))
-            })),
-            LexItem(Symbol(1), character({ 'b' })),
-          })
+                repeat1(seq({
+                  character({ 'a' }),
+                  character({ 'b' }),
+                }))
+              })),
+              LexItem(Symbol(1), character({ 'b' })),
+            }),
+            PrecedenceRange()
+          }
         },
         {
           CharacterSet().include('c'),
-          LexItemSet({
-            LexItem(Symbol(2), repeat1(character({ 'c' }))),
-            LexItem(Symbol(2), blank()),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(2), repeat1(character({ 'c' }))),
+              LexItem(Symbol(2), blank()),
+            }),
+            PrecedenceRange()
+          }
+        }
+      })));
+  });
+
+  it("handles repeats with precedence", [&]() {
+    LexItemSet item_set({
+      LexItem(Symbol(1), prec(-1, repeat1(character({ 'a' }))))
+    });
+
+    AssertThat(
+      item_set.transitions(),
+      Equals(LexItemSet::TransitionMap({
+        {
+          CharacterSet().include('a'),
+          {
+            LexItemSet({
+              LexItem(Symbol(1), prec(-1, repeat1(character({ 'a' })))),
+              LexItem(Symbol(1), prec(-1, blank())),
+            }),
+            PrecedenceRange(-1)
+          }
         }
       })));
   });
@@ -163,38 +283,47 @@ describe("LexItemSet::transitions()", [&]() {
   it("handles choices between overlapping character sets", [&]() {
     LexItemSet item_set({
       LexItem(Symbol(1), choice({
-        seq({
+        prec(2, seq({
           character({ 'a', 'b', 'c', 'd'  }),
           character({ 'x' }),
-        }),
-        seq({
+        })),
+        prec(3, seq({
           character({ 'c', 'd', 'e', 'f' }),
           character({ 'y' }),
-        }),
+        })),
       }))
     });
 
     AssertThat(
       item_set.transitions(),
-      Equals(map<CharacterSet, LexItemSet>({
+      Equals(LexItemSet::TransitionMap({
         {
           CharacterSet().include('a', 'b'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ 'x' })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), prec(2, character({ 'x' }))),
+            }),
+            PrecedenceRange(2)
+          }
         },
         {
           CharacterSet().include('c', 'd'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ 'x' })),
-            LexItem(Symbol(1), character({ 'y' })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), prec(2, character({ 'x' }))),
+              LexItem(Symbol(1), prec(3, character({ 'y' }))),
+            }),
+            PrecedenceRange(2, 3)
+          }
         },
         {
           CharacterSet().include('e', 'f'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ 'y' })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), prec(3, character({ 'y' }))),
+            }),
+            PrecedenceRange(3)
+          }
         },
       })));
   });
@@ -215,19 +344,25 @@ describe("LexItemSet::transitions()", [&]() {
 
     AssertThat(
       item_set.transitions(),
-      Equals(map<CharacterSet, LexItemSet>({
+      Equals(LexItemSet::TransitionMap({
         {
           CharacterSet().include('a').include('e', 'f'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ 'y' })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), character({ 'y' })),
+            }),
+            PrecedenceRange()
+          }
         },
         {
           CharacterSet().include('b', 'd'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ 'x' })),
-            LexItem(Symbol(1), character({ 'y' })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), character({ 'x' })),
+              LexItem(Symbol(1), character({ 'y' })),
+            }),
+            PrecedenceRange()
+          }
         },
       })));
   });
@@ -248,19 +383,25 @@ describe("LexItemSet::transitions()", [&]() {
 
     AssertThat(
       item_set.transitions(),
-      Equals(map<CharacterSet, LexItemSet>({
+      Equals(LexItemSet::TransitionMap({
         {
           CharacterSet().include_all().exclude('/').exclude('\\'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ '/' })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), character({ '/' })),
+            }),
+            PrecedenceRange()
+          }
         },
         {
           CharacterSet().include('\\'),
-          LexItemSet({
-            LexItem(Symbol(1), character({ '/' })),
-            LexItem(Symbol(1), seq({ character({ '/' }), character({ '/' }) })),
-          })
+          {
+            LexItemSet({
+              LexItem(Symbol(1), character({ '/' })),
+              LexItem(Symbol(1), seq({ character({ '/' }), character({ '/' }) })),
+            }),
+            PrecedenceRange()
+          }
         },
       })));
   });
@@ -271,25 +412,34 @@ describe("LexItemSet::transitions()", [&]() {
       LexItem(Symbol(2), character({ 'e', 'f', 'g', 'h', 'i' }))
     });
 
-    AssertThat(set1.transitions(), Equals(map<CharacterSet, LexItemSet>({
+    AssertThat(set1.transitions(), Equals(LexItemSet::TransitionMap({
       {
         CharacterSet().include('a', 'd'),
-        LexItemSet({
-          LexItem(Symbol(1), blank()),
-        })
+        {
+          LexItemSet({
+            LexItem(Symbol(1), blank()),
+          }),
+          PrecedenceRange()
+        }
       },
       {
         CharacterSet().include('e', 'f'),
-        LexItemSet({
-          LexItem(Symbol(1), blank()),
-          LexItem(Symbol(2), blank()),
-        })
+        {
+          LexItemSet({
+            LexItem(Symbol(1), blank()),
+            LexItem(Symbol(2), blank()),
+          }),
+          PrecedenceRange()
+        }
       },
       {
         CharacterSet().include('g', 'i'),
-        LexItemSet({
-          LexItem(Symbol(2), blank()),
-        })
+        {
+          LexItemSet({
+            LexItem(Symbol(2), blank()),
+          }),
+          PrecedenceRange()
+        }
       },
     })));
   });
diff --git a/spec/compiler/build_tables/parse_item_spec.cc b/spec/compiler/build_tables/parse_item_spec.cc
index 9a7ed30f..64a055b3 100644
--- a/spec/compiler/build_tables/parse_item_spec.cc
+++ b/spec/compiler/build_tables/parse_item_spec.cc
@@ -8,69 +8,147 @@ using namespace build_tables;
 
 START_TEST
 
-describe("parse_item_set_transitions(ParseItemSet, SyntaxGrammar)", [&]() {
-  it("computes the closure of the new item sets", [&]() {
-    SyntaxGrammar grammar{{
-      SyntaxVariable("rule_0", VariableTypeNamed, {
-        Production({
-          {Symbol(11, true), 0, AssociativityNone, 101},
-          {Symbol(12, true), 0, AssociativityNone, 102},
-          {Symbol(1), 0, AssociativityNone, 103},
-          {Symbol(13, true), 0, AssociativityNone, 104},
-        })
+describe("ParseItem::completion_status()", [&]() {
+  SyntaxGrammar grammar{{
+    SyntaxVariable("rule_0", VariableTypeNamed, {
+      Production({
+        {Symbol(11, true), 0, AssociativityNone, 101},
+        {Symbol(12, true), 0, AssociativityNone, 102},
+        {Symbol(13), 0, AssociativityNone, 103},
+        {Symbol(14, true), 4, AssociativityLeft, 104},
       }),
-      SyntaxVariable("rule_1", VariableTypeNamed, {
-        Production({
-          {Symbol(2), 0, AssociativityNone, 105},
-          {Symbol(14, true), 0, AssociativityNone, 106},
-        })
+      Production({
+        {Symbol(15, true), 0, AssociativityNone, 101},
+        {Symbol(16, true), 0, AssociativityNone, 102},
+        {Symbol(17, true), 5, AssociativityRight, 104},
       }),
-      SyntaxVariable("rule_2", VariableTypeNamed, {
-        Production({
-          {Symbol(15, true), 0, AssociativityNone, 105},
-        })
+      Production({}),
+    }),
+  }, {}, {}};
+
+  auto production = [&](int variable_index, int production_index) -> const Production & {
+    return grammar.variables[variable_index].productions[production_index];
+  };
+
+  it("indicates whether the parse item is done, and its associativity and precedence", [&]() {
+    ParseItem item(Symbol(0), production(0, 0), 3);
+    AssertThat(item.completion_status().is_done, IsFalse());
+    AssertThat(item.completion_status().precedence, Equals(0));
+    AssertThat(item.completion_status().associativity, Equals(AssociativityNone));
+
+    item = ParseItem(Symbol(0), production(0, 0), 4);
+    AssertThat(item.completion_status().is_done, IsTrue());
+    AssertThat(item.completion_status().precedence, Equals(4));
+    AssertThat(item.completion_status().associativity, Equals(AssociativityLeft));
+
+    item = ParseItem(Symbol(0), production(0, 1), 3);
+    AssertThat(item.completion_status().is_done, IsTrue());
+    AssertThat(item.completion_status().precedence, Equals(5));
+    AssertThat(item.completion_status().associativity, Equals(AssociativityRight));
+
+    item = ParseItem(Symbol(0), production(0, 2), 0);
+    AssertThat(item.completion_status().is_done, IsTrue());
+    AssertThat(item.completion_status().precedence, Equals(0));
+    AssertThat(item.completion_status().associativity, Equals(AssociativityNone));
+  });
+});
+
+describe("ParseItemSet::transitions())", [&]() {
+  SyntaxGrammar grammar{{
+    SyntaxVariable("rule_0", VariableTypeNamed, {
+      Production({
+        {Symbol(11, true), 0, AssociativityNone, 101},
+        {Symbol(12, true), 0, AssociativityNone, 102},
+        {Symbol(13), 5, AssociativityNone, 103},
+        {Symbol(14, true), 0, AssociativityNone, 104},
+      }),
+      Production({
+        {Symbol(11, true), 0, AssociativityNone, 105},
+        {Symbol(12, true), 0, AssociativityNone, 106},
+        {Symbol(15), 6, AssociativityNone, 107},
       })
-    }, {}, {}};
+    }),
+    SyntaxVariable("rule_1", VariableTypeNamed, {
+      Production({
+        {Symbol(15), 7, AssociativityNone, 109},
+        {Symbol(16, true), 0, AssociativityNone, 110},
+      })
+    }),
+    SyntaxVariable("rule_2", VariableTypeNamed, {
+      Production({
+        {Symbol(18, true), 0, AssociativityNone, 111},
+      })
+    })
+  }, {}, {}};
 
-    auto production = [&](int variable_index, int production_index) -> const Production & {
-      return grammar.variables[variable_index].productions[production_index];
-    };
+  auto production = [&](int variable_index, int production_index) -> const Production & {
+    return grammar.variables[variable_index].productions[production_index];
+  };
 
-    ParseItemSet set1({
+  it("computes the ParseItemSet that would occur after consuming each lookahead symbol, along with its precedence", [&]() {
+    ParseItemSet item_set({
+
+      // Two symbols into the first production for rule_0
       {
         ParseItem(Symbol(0), production(0, 0), 2),
-        LookaheadSet({ Symbol(16, true) })
+        LookaheadSet({ Symbol(21, true) })
       },
+
+      // Two symbols into the second production for rule_0
+      {
+        ParseItem(Symbol(0), production(0, 1), 2),
+        LookaheadSet({ Symbol(21, true) })
+      },
+
+      // At the beginning of the first production for rule_1
       {
         ParseItem(Symbol(1), production(1, 0), 0),
-        LookaheadSet({ Symbol(17, true) })
+        LookaheadSet({ Symbol(22, true) })
       },
+
+      // At the end of the first production for rule_2
       {
         ParseItem(Symbol(2), production(2, 0), 1),
-        LookaheadSet({ Symbol(17, true) })
+        LookaheadSet({ Symbol(22, true) })
       }
     });
 
-    AssertThat(set1.transitions(), Equals(map<Symbol, ParseItemSet>({
+    AssertThat(item_set.transitions(), Equals(ParseItemSet::TransitionMap({
+
+      // For the first item, symbol 13 is next, with precedence 5.
       {
-        Symbol(1),
-        ParseItemSet({
-          {
-            ParseItem(Symbol(0), production(0, 0), 3),
-            LookaheadSet({ Symbol(16, true) })
-          }
-        })
+        Symbol(13),
+        {
+          ParseItemSet({
+            {
+              ParseItem(Symbol(0), production(0, 0), 3),
+              LookaheadSet({ Symbol(21, true) })
+            }
+          }),
+          PrecedenceRange(5, 5)
+        }
       },
 
+      // For the second and third item, symbol 15 is next, with two different
+      // precedence values.
       {
-        Symbol(2),
-        ParseItemSet({
-          {
-            ParseItem(Symbol(1), production(1, 0), 1),
-            LookaheadSet({ Symbol(17, true) })
-          },
-        })
+        Symbol(15),
+        {
+          ParseItemSet({
+            {
+              ParseItem(Symbol(0), production(0, 1), 3),
+              LookaheadSet({ Symbol(21, true) })
+            },
+            {
+              ParseItem(Symbol(1), production(1, 0), 1),
+              LookaheadSet({ Symbol(22, true) })
+            },
+          }),
+          PrecedenceRange(6, 7)
+        }
       },
+
+      // The third item is at the end of its production: no transitions.
     })));
   });
 });
diff --git a/spec/compiler/helpers/stream_methods.cc b/spec/compiler/helpers/stream_methods.cc
index fe25d822..8f0a1b07 100644
--- a/spec/compiler/helpers/stream_methods.cc
+++ b/spec/compiler/helpers/stream_methods.cc
@@ -5,7 +5,6 @@
 #include "compiler/syntax_grammar.h"
 #include "compiler/build_tables/parse_item.h"
 #include "compiler/build_tables/lex_item.h"
-#include "compiler/build_tables/get_metadata.h"
 
 namespace tree_sitter {
 
@@ -110,7 +109,10 @@ ostream &operator<<(ostream &stream, const ProductionStep &step) {
 }
 
 ostream &operator<<(ostream &stream, const PrecedenceRange &range) {
-  return stream << string("{") << to_string(range.min) << string(", ") << to_string(range.max) << string("}");
+  if (range.empty)
+    return stream << string("{empty}");
+  else
+    return stream << string("{") << to_string(range.min) << string(", ") << to_string(range.max) << string("}");
 }
 
 namespace build_tables {
@@ -126,7 +128,7 @@ ostream &operator<<(ostream &stream, const LexItemSet &item_set) {
 
 ostream &operator<<(ostream &stream, const ParseItem &item) {
   return stream << string("(item variable:") << to_string(item.variable_index)
-                << string(" production:") << to_string((size_t)&item.production % 1000)
+                << string(" production:") << to_string((size_t)item.production % 1000)
                 << string(" step:") << to_string(item.step_index)
                 << string(")");
 }
@@ -135,11 +137,6 @@ std::ostream &operator<<(std::ostream &stream, const ParseItemSet &item_set) {
   return stream << item_set.entries;
 }
 
-std::ostream &operator<<(std::ostream &stream, const MetadataRange &range) {
-  return stream << string("{") << to_string(range.min) << string(", ")
-                << to_string(range.max) << string("}");
-}
-
 std::ostream &operator<<(std::ostream &stream, const LookaheadSet &set) {
   return stream << *set.entries;
 }
diff --git a/spec/compiler/helpers/stream_methods.h b/spec/compiler/helpers/stream_methods.h
index cd132a03..1a9b9aaa 100644
--- a/spec/compiler/helpers/stream_methods.h
+++ b/spec/compiler/helpers/stream_methods.h
@@ -111,14 +111,12 @@ ostream &operator<<(ostream &, const PrecedenceRange &);
 
 namespace build_tables {
 
-struct MetadataRange;
 class LexItem;
 class LexItemSet;
 class ParseItem;
 class ParseItemSet;
 class LookaheadSet;
 
-ostream &operator<<(ostream &, const MetadataRange &);
 ostream &operator<<(ostream &, const LexItem &);
 ostream &operator<<(ostream &, const LexItemSet &);
 ostream &operator<<(ostream &, const ParseItem &);
diff --git a/spec/compiler/prepare_grammar/expand_tokens_spec.cc b/spec/compiler/prepare_grammar/expand_tokens_spec.cc
index b0c7462f..3b394452 100644
--- a/spec/compiler/prepare_grammar/expand_tokens_spec.cc
+++ b/spec/compiler/prepare_grammar/expand_tokens_spec.cc
@@ -29,7 +29,7 @@ describe("expand_tokens", []() {
             character({ 'y' }),
             character({ 'z' }),
           }), {
-            {PRECEDENCE, 1},
+            {IS_STRING, 1},
             {IS_TOKEN, 1},
           }),
           i_sym(11),
@@ -50,7 +50,7 @@ describe("expand_tokens", []() {
           character({ ' ' }),
           character({ 946 }),
         }), {
-          {PRECEDENCE, 1},
+          {IS_STRING, 1},
           {IS_TOKEN, 1},
         })),
       })));
diff --git a/spec/fixtures/grammars/c.cc b/spec/fixtures/grammars/c.cc
index 8ffaa007..8dbba4f3 100644
--- a/spec/fixtures/grammars/c.cc
+++ b/spec/fixtures/grammars/c.cc
@@ -14,7 +14,8 @@ extern const Grammar c = Grammar({
   { "preproc_define", seq({
     str("#define"),
     sym("identifier"),
-    token(repeat(choice({ str("\\\n"), pattern(".") }))) }) },
+    optional(token(prec(-1, repeat1(choice({ str("\\\n"), pattern(".") }))))),
+    str("\n") }) },
 
   { "function_definition", seq({
     optional(sym("declaration_specifiers")),
diff --git a/spec/fixtures/parsers/c.c b/spec/fixtures/parsers/c.c
index 647f5ea4..5e169b66 100644
--- a/spec/fixtures/parsers/c.c
+++ b/spec/fixtures/parsers/c.c
@@ -1,7 +1,7 @@
 #include "tree_sitter/parser.h"
 
-#define STATE_COUNT 266
-#define SYMBOL_COUNT 69
+#define STATE_COUNT 268
+#define SYMBOL_COUNT 70
 
 enum {
     sym_program = ts_builtin_sym_start,
@@ -41,7 +41,8 @@ enum {
     aux_sym_compound_statement_repeat1,
     aux_sym_call_expression_repeat1,
     anon_sym_POUNDdefine,
-    aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH,
+    aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH,
+    anon_sym_LF,
     anon_sym_typedef,
     anon_sym_extern,
     anon_sym_static,
@@ -113,7 +114,8 @@ static const char *ts_symbol_names[] = {
     [ts_builtin_sym_error] = "ERROR",
     [ts_builtin_sym_end] = "END",
     [anon_sym_POUNDdefine] = "#define",
-    [aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH] = "/((\\n|.)*|)/",
+    [aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH] = "/(\\n|.)*/",
+    [anon_sym_LF] = "\n",
     [anon_sym_typedef] = "typedef",
     [anon_sym_extern] = "extern",
     [anon_sym_static] = "static",
@@ -185,7 +187,8 @@ static const TSNodeType ts_node_types[SYMBOL_COUNT] = {
     [ts_builtin_sym_error] = TSNodeTypeNamed,
     [ts_builtin_sym_end] = TSNodeTypeHidden,
     [anon_sym_POUNDdefine] = TSNodeTypeAnonymous,
-    [aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH] = TSNodeTypeHidden,
+    [aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH] = TSNodeTypeHidden,
+    [anon_sym_LF] = TSNodeTypeAnonymous,
     [anon_sym_typedef] = TSNodeTypeAnonymous,
     [anon_sym_extern] = TSNodeTypeAnonymous,
     [anon_sym_static] = TSNodeTypeAnonymous,
@@ -1552,11 +1555,11 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == ' '))
                 ADVANCE(130);
             if (lookahead == '\n')
-                ADVANCE(131);
+                ADVANCE(137);
             if (lookahead == '/')
-                ADVANCE(132);
+                ADVANCE(131);
             if (lookahead == '\\')
-                ADVANCE(136);
+                ADVANCE(134);
             if (!((lookahead == 0) ||
                 (lookahead == '\t') ||
                 (lookahead == '\n') ||
@@ -1564,20 +1567,18 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == ' ') ||
                 (lookahead == '/') ||
                 (lookahead == '\\')))
-                ADVANCE(137);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
+                ADVANCE(136);
+            LEX_ERROR();
         case 130:
             START_TOKEN();
             if ((lookahead == '\t') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(130);
-            if (lookahead == '\n')
-                ADVANCE(131);
             if (lookahead == '/')
-                ADVANCE(132);
+                ADVANCE(131);
             if (lookahead == '\\')
-                ADVANCE(136);
+                ADVANCE(134);
             if (!((lookahead == 0) ||
                 (lookahead == '\t') ||
                 (lookahead == '\n') ||
@@ -1585,48 +1586,27 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == ' ') ||
                 (lookahead == '/') ||
                 (lookahead == '\\')))
-                ADVANCE(137);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
+                ADVANCE(136);
+            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH);
         case 131:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(130);
-            if (lookahead == '\n')
-                ADVANCE(131);
             if (lookahead == '/')
                 ADVANCE(132);
-            if (lookahead == '\\')
-                ADVANCE(136);
-            if (!((lookahead == 0) ||
-                (lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' ') ||
-                (lookahead == '/') ||
-                (lookahead == '\\')))
-                ADVANCE(137);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
-        case 132:
-            if (lookahead == '/')
-                ADVANCE(133);
-            if (lookahead == '\\')
-                ADVANCE(136);
-            if (!((lookahead == 0) ||
-                (lookahead == '\n') ||
-                (lookahead == '/') ||
-                (lookahead == '\\')))
-                ADVANCE(137);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
-        case 133:
             if (lookahead == '\\')
                 ADVANCE(134);
             if (!((lookahead == 0) ||
                 (lookahead == '\n') ||
+                (lookahead == '/') ||
                 (lookahead == '\\')))
+                ADVANCE(136);
+            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH);
+        case 132:
+            if (lookahead == '\\')
                 ADVANCE(133);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
+            ACCEPT_TOKEN(sym_comment);
+        case 133:
+            if (lookahead == '\\')
+                ADVANCE(133);
+            ACCEPT_TOKEN(sym_comment);
         case 134:
             if (lookahead == '\n')
                 ADVANCE(135);
@@ -1635,50 +1615,45 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (!((lookahead == 0) ||
                 (lookahead == '\n') ||
                 (lookahead == '\\')))
-                ADVANCE(133);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
+                ADVANCE(136);
+            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH);
         case 135:
             if (lookahead == '\\')
-                ADVANCE(136);
+                ADVANCE(134);
             if (!((lookahead == 0) ||
                 (lookahead == '\n') ||
                 (lookahead == '\\')))
-                ADVANCE(137);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
+                ADVANCE(136);
+            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH);
         case 136:
-            if (lookahead == '\n')
-                ADVANCE(135);
             if (lookahead == '\\')
-                ADVANCE(136);
+                ADVANCE(134);
             if (!((lookahead == 0) ||
                 (lookahead == '\n') ||
                 (lookahead == '\\')))
-                ADVANCE(137);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
+                ADVANCE(136);
+            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH);
         case 137:
+            START_TOKEN();
             if (lookahead == '\\')
-                ADVANCE(136);
-            if (!((lookahead == 0) ||
-                (lookahead == '\n') ||
-                (lookahead == '\\')))
-                ADVANCE(137);
-            ACCEPT_TOKEN(aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH);
+                ADVANCE(134);
+            ACCEPT_TOKEN(anon_sym_LF);
         case 138:
             START_TOKEN();
             if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(138);
-            if (lookahead == ',')
-                ADVANCE(122);
+            if (lookahead == '\n')
+                ADVANCE(139);
             if (lookahead == '/')
                 ADVANCE(10);
-            if (lookahead == ';')
-                ADVANCE(139);
             LEX_ERROR();
         case 139:
-            ACCEPT_TOKEN(anon_sym_SEMI);
+            START_TOKEN();
+            if (lookahead == '/')
+                ADVANCE(10);
+            ACCEPT_TOKEN(anon_sym_LF);
         case 140:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1691,39 +1666,10 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '/')
                 ADVANCE(10);
             if (lookahead == ';')
-                ADVANCE(139);
-            if (lookahead == '=')
                 ADVANCE(141);
-            if (('A' <= lookahead && lookahead <= 'Z') ||
-                (lookahead == 'b') ||
-                (lookahead == 'd') ||
-                ('f' <= lookahead && lookahead <= 'k') ||
-                ('m' <= lookahead && lookahead <= 'q') ||
-                ('w' <= lookahead && lookahead <= 'z'))
-                ADVANCE(12);
-            if (lookahead == 'a')
-                ADVANCE(13);
-            if (lookahead == 'c')
-                ADVANCE(17);
-            if (lookahead == 'e')
-                ADVANCE(22);
-            if (lookahead == 'l')
-                ADVANCE(28);
-            if (lookahead == 'r')
-                ADVANCE(32);
-            if (lookahead == 's')
-                ADVANCE(46);
-            if (lookahead == 't')
-                ADVANCE(65);
-            if (lookahead == 'u')
-                ADVANCE(72);
-            if (lookahead == 'v')
-                ADVANCE(80);
-            if (lookahead == '{')
-                ADVANCE(100);
             LEX_ERROR();
         case 141:
-            ACCEPT_TOKEN(anon_sym_EQ);
+            ACCEPT_TOKEN(anon_sym_SEMI);
         case 142:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1731,16 +1677,14 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(142);
-            if (lookahead == '(')
-                ADVANCE(94);
             if (lookahead == ',')
                 ADVANCE(122);
             if (lookahead == '/')
                 ADVANCE(10);
             if (lookahead == ';')
-                ADVANCE(139);
-            if (lookahead == '=')
                 ADVANCE(141);
+            if (lookahead == '=')
+                ADVANCE(143);
             if (('A' <= lookahead && lookahead <= 'Z') ||
                 (lookahead == 'b') ||
                 (lookahead == 'd') ||
@@ -1748,8 +1692,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ('m' <= lookahead && lookahead <= 'q') ||
                 ('w' <= lookahead && lookahead <= 'z'))
                 ADVANCE(12);
-            if (lookahead == '[')
-                ADVANCE(106);
             if (lookahead == 'a')
                 ADVANCE(13);
             if (lookahead == 'c')
@@ -1772,14 +1714,24 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(100);
             LEX_ERROR();
         case 143:
+            ACCEPT_TOKEN(anon_sym_EQ);
+        case 144:
             START_TOKEN();
             if ((lookahead == '\t') ||
                 (lookahead == '\n') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
-                ADVANCE(143);
+                ADVANCE(144);
+            if (lookahead == '(')
+                ADVANCE(94);
+            if (lookahead == ',')
+                ADVANCE(122);
             if (lookahead == '/')
                 ADVANCE(10);
+            if (lookahead == ';')
+                ADVANCE(141);
+            if (lookahead == '=')
+                ADVANCE(143);
             if (('A' <= lookahead && lookahead <= 'Z') ||
                 (lookahead == 'b') ||
                 (lookahead == 'd') ||
@@ -1787,6 +1739,8 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ('m' <= lookahead && lookahead <= 'q') ||
                 ('w' <= lookahead && lookahead <= 'z'))
                 ADVANCE(12);
+            if (lookahead == '[')
+                ADVANCE(106);
             if (lookahead == 'a')
                 ADVANCE(13);
             if (lookahead == 'c')
@@ -1808,19 +1762,15 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '{')
                 ADVANCE(100);
             LEX_ERROR();
-        case 144:
+        case 145:
             START_TOKEN();
             if ((lookahead == '\t') ||
                 (lookahead == '\n') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
-                ADVANCE(144);
-            if (lookahead == '\"')
-                ADVANCE(112);
+                ADVANCE(145);
             if (lookahead == '/')
                 ADVANCE(10);
-            if ('0' <= lookahead && lookahead <= '9')
-                ADVANCE(116);
             if (('A' <= lookahead && lookahead <= 'Z') ||
                 (lookahead == 'b') ||
                 (lookahead == 'd') ||
@@ -1846,25 +1796,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(72);
             if (lookahead == 'v')
                 ADVANCE(80);
-            if (lookahead == '}')
-                ADVANCE(102);
-            LEX_ERROR();
-        case 145:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(145);
-            if (lookahead == '\"')
-                ADVANCE(112);
-            if (lookahead == '/')
-                ADVANCE(10);
-            if ('0' <= lookahead && lookahead <= '9')
-                ADVANCE(116);
-            if (('A' <= lookahead && lookahead <= 'Z') ||
-                ('a' <= lookahead && lookahead <= 'z'))
-                ADVANCE(12);
             if (lookahead == '{')
                 ADVANCE(100);
             LEX_ERROR();
@@ -1875,18 +1806,39 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(146);
-            if (lookahead == '(')
-                ADVANCE(94);
-            if (lookahead == '*')
-                ADVANCE(95);
-            if (lookahead == '+')
-                ADVANCE(125);
-            if (lookahead == ',')
-                ADVANCE(122);
+            if (lookahead == '\"')
+                ADVANCE(112);
             if (lookahead == '/')
                 ADVANCE(10);
-            if (lookahead == ';')
-                ADVANCE(139);
+            if ('0' <= lookahead && lookahead <= '9')
+                ADVANCE(116);
+            if (('A' <= lookahead && lookahead <= 'Z') ||
+                (lookahead == 'b') ||
+                (lookahead == 'd') ||
+                ('f' <= lookahead && lookahead <= 'k') ||
+                ('m' <= lookahead && lookahead <= 'q') ||
+                ('w' <= lookahead && lookahead <= 'z'))
+                ADVANCE(12);
+            if (lookahead == 'a')
+                ADVANCE(13);
+            if (lookahead == 'c')
+                ADVANCE(17);
+            if (lookahead == 'e')
+                ADVANCE(22);
+            if (lookahead == 'l')
+                ADVANCE(28);
+            if (lookahead == 'r')
+                ADVANCE(32);
+            if (lookahead == 's')
+                ADVANCE(46);
+            if (lookahead == 't')
+                ADVANCE(65);
+            if (lookahead == 'u')
+                ADVANCE(72);
+            if (lookahead == 'v')
+                ADVANCE(80);
+            if (lookahead == '}')
+                ADVANCE(102);
             LEX_ERROR();
         case 147:
             START_TOKEN();
@@ -1897,8 +1849,47 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(147);
             if (lookahead == '\"')
                 ADVANCE(112);
-            if (lookahead == '.')
+            if (lookahead == '/')
+                ADVANCE(10);
+            if ('0' <= lookahead && lookahead <= '9')
+                ADVANCE(116);
+            if (('A' <= lookahead && lookahead <= 'Z') ||
+                ('a' <= lookahead && lookahead <= 'z'))
+                ADVANCE(12);
+            if (lookahead == '{')
+                ADVANCE(100);
+            LEX_ERROR();
+        case 148:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\n') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
                 ADVANCE(148);
+            if (lookahead == '(')
+                ADVANCE(94);
+            if (lookahead == '*')
+                ADVANCE(95);
+            if (lookahead == '+')
+                ADVANCE(125);
+            if (lookahead == ',')
+                ADVANCE(122);
+            if (lookahead == '/')
+                ADVANCE(10);
+            if (lookahead == ';')
+                ADVANCE(141);
+            LEX_ERROR();
+        case 149:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\n') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(149);
+            if (lookahead == '\"')
+                ADVANCE(112);
+            if (lookahead == '.')
+                ADVANCE(150);
             if (lookahead == '/')
                 ADVANCE(10);
             if ('0' <= lookahead && lookahead <= '9')
@@ -1911,42 +1902,8 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '{')
                 ADVANCE(100);
             LEX_ERROR();
-        case 148:
-            ACCEPT_TOKEN(anon_sym_DOT);
-        case 149:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(149);
-            if (lookahead == ',')
-                ADVANCE(122);
-            if (lookahead == '/')
-                ADVANCE(10);
-            if (lookahead == '}')
-                ADVANCE(102);
-            LEX_ERROR();
         case 150:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(150);
-            if (lookahead == '(')
-                ADVANCE(94);
-            if (lookahead == '*')
-                ADVANCE(95);
-            if (lookahead == '+')
-                ADVANCE(125);
-            if (lookahead == ',')
-                ADVANCE(122);
-            if (lookahead == '/')
-                ADVANCE(10);
-            if (lookahead == '}')
-                ADVANCE(102);
-            LEX_ERROR();
+            ACCEPT_TOKEN(anon_sym_DOT);
         case 151:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1954,10 +1911,12 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(151);
+            if (lookahead == ',')
+                ADVANCE(122);
             if (lookahead == '/')
                 ADVANCE(10);
-            if (lookahead == '=')
-                ADVANCE(141);
+            if (lookahead == '}')
+                ADVANCE(102);
             LEX_ERROR();
         case 152:
             START_TOKEN();
@@ -1966,14 +1925,18 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(152);
-            if (lookahead == '.')
-                ADVANCE(148);
+            if (lookahead == '(')
+                ADVANCE(94);
+            if (lookahead == '*')
+                ADVANCE(95);
+            if (lookahead == '+')
+                ADVANCE(125);
+            if (lookahead == ',')
+                ADVANCE(122);
             if (lookahead == '/')
                 ADVANCE(10);
-            if (lookahead == '=')
-                ADVANCE(141);
-            if (lookahead == '[')
-                ADVANCE(106);
+            if (lookahead == '}')
+                ADVANCE(102);
             LEX_ERROR();
         case 153:
             START_TOKEN();
@@ -1982,10 +1945,38 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(153);
+            if (lookahead == '/')
+                ADVANCE(10);
+            if (lookahead == '=')
+                ADVANCE(143);
+            LEX_ERROR();
+        case 154:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\n') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(154);
+            if (lookahead == '.')
+                ADVANCE(150);
+            if (lookahead == '/')
+                ADVANCE(10);
+            if (lookahead == '=')
+                ADVANCE(143);
+            if (lookahead == '[')
+                ADVANCE(106);
+            LEX_ERROR();
+        case 155:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\n') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(155);
             if (lookahead == '\"')
                 ADVANCE(112);
             if (lookahead == '.')
-                ADVANCE(148);
+                ADVANCE(150);
             if (lookahead == '/')
                 ADVANCE(10);
             if ('0' <= lookahead && lookahead <= '9')
@@ -2000,45 +1991,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '}')
                 ADVANCE(102);
             LEX_ERROR();
-        case 154:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(154);
-            if (lookahead == '(')
-                ADVANCE(94);
-            if (lookahead == '*')
-                ADVANCE(95);
-            if (lookahead == '+')
-                ADVANCE(125);
-            if (lookahead == '/')
-                ADVANCE(10);
-            if (lookahead == ';')
-                ADVANCE(139);
-            LEX_ERROR();
-        case 155:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(155);
-            if (lookahead == '(')
-                ADVANCE(94);
-            if (lookahead == '*')
-                ADVANCE(95);
-            if (lookahead == '+')
-                ADVANCE(125);
-            if (lookahead == '/')
-                ADVANCE(10);
-            if (lookahead == ';')
-                ADVANCE(139);
-            if (('A' <= lookahead && lookahead <= 'Z') ||
-                ('a' <= lookahead && lookahead <= 'z'))
-                ADVANCE(12);
-            LEX_ERROR();
         case 156:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -2046,13 +1998,15 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(156);
-            if (lookahead == ',')
-                ADVANCE(122);
+            if (lookahead == '(')
+                ADVANCE(94);
+            if (lookahead == '*')
+                ADVANCE(95);
+            if (lookahead == '+')
+                ADVANCE(125);
             if (lookahead == '/')
                 ADVANCE(10);
             if (lookahead == ';')
-                ADVANCE(139);
-            if (lookahead == '=')
                 ADVANCE(141);
             LEX_ERROR();
         case 157:
@@ -2064,16 +2018,17 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(157);
             if (lookahead == '(')
                 ADVANCE(94);
-            if (lookahead == ',')
-                ADVANCE(122);
+            if (lookahead == '*')
+                ADVANCE(95);
+            if (lookahead == '+')
+                ADVANCE(125);
             if (lookahead == '/')
                 ADVANCE(10);
             if (lookahead == ';')
-                ADVANCE(139);
-            if (lookahead == '=')
                 ADVANCE(141);
-            if (lookahead == '[')
-                ADVANCE(106);
+            if (('A' <= lookahead && lookahead <= 'Z') ||
+                ('a' <= lookahead && lookahead <= 'z'))
+                ADVANCE(12);
             LEX_ERROR();
         case 158:
             START_TOKEN();
@@ -2082,20 +2037,57 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(158);
+            if (lookahead == ',')
+                ADVANCE(122);
             if (lookahead == '/')
                 ADVANCE(10);
             if (lookahead == ';')
-                ADVANCE(139);
+                ADVANCE(141);
+            if (lookahead == '=')
+                ADVANCE(143);
             LEX_ERROR();
         case 159:
             START_TOKEN();
-            if (lookahead == 0)
-                ADVANCE(2);
             if ((lookahead == '\t') ||
                 (lookahead == '\n') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
                 ADVANCE(159);
+            if (lookahead == '(')
+                ADVANCE(94);
+            if (lookahead == ',')
+                ADVANCE(122);
+            if (lookahead == '/')
+                ADVANCE(10);
+            if (lookahead == ';')
+                ADVANCE(141);
+            if (lookahead == '=')
+                ADVANCE(143);
+            if (lookahead == '[')
+                ADVANCE(106);
+            LEX_ERROR();
+        case 160:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\n') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(160);
+            if (lookahead == '/')
+                ADVANCE(10);
+            if (lookahead == ';')
+                ADVANCE(141);
+            LEX_ERROR();
+        case 161:
+            START_TOKEN();
+            if (lookahead == 0)
+                ADVANCE(2);
+            if ((lookahead == '\t') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(161);
+            if (lookahead == '\n')
+                ADVANCE(162);
             if (lookahead == '\"')
                 ADVANCE(112);
             if (lookahead == '#')
@@ -2111,15 +2103,15 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ',')
                 ADVANCE(122);
             if (lookahead == '.')
-                ADVANCE(148);
+                ADVANCE(150);
             if (lookahead == '/')
                 ADVANCE(10);
             if ('0' <= lookahead && lookahead <= '9')
                 ADVANCE(116);
             if (lookahead == ';')
-                ADVANCE(139);
-            if (lookahead == '=')
                 ADVANCE(141);
+            if (lookahead == '=')
+                ADVANCE(143);
             if (('A' <= lookahead && lookahead <= 'Z') ||
                 (lookahead == 'b') ||
                 (lookahead == 'd') ||
@@ -2154,15 +2146,10 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '}')
                 ADVANCE(102);
             LEX_ERROR();
-        case ts_lex_state_error:
+        case 162:
             START_TOKEN();
             if (lookahead == 0)
                 ADVANCE(2);
-            if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(159);
             if (lookahead == '\"')
                 ADVANCE(112);
             if (lookahead == '#')
@@ -2178,15 +2165,83 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ',')
                 ADVANCE(122);
             if (lookahead == '.')
-                ADVANCE(148);
+                ADVANCE(150);
             if (lookahead == '/')
                 ADVANCE(10);
             if ('0' <= lookahead && lookahead <= '9')
                 ADVANCE(116);
             if (lookahead == ';')
-                ADVANCE(139);
-            if (lookahead == '=')
                 ADVANCE(141);
+            if (lookahead == '=')
+                ADVANCE(143);
+            if (('A' <= lookahead && lookahead <= 'Z') ||
+                (lookahead == 'b') ||
+                (lookahead == 'd') ||
+                ('f' <= lookahead && lookahead <= 'k') ||
+                ('m' <= lookahead && lookahead <= 'q') ||
+                ('w' <= lookahead && lookahead <= 'z'))
+                ADVANCE(12);
+            if (lookahead == '[')
+                ADVANCE(106);
+            if (lookahead == ']')
+                ADVANCE(119);
+            if (lookahead == 'a')
+                ADVANCE(13);
+            if (lookahead == 'c')
+                ADVANCE(17);
+            if (lookahead == 'e')
+                ADVANCE(22);
+            if (lookahead == 'l')
+                ADVANCE(28);
+            if (lookahead == 'r')
+                ADVANCE(32);
+            if (lookahead == 's')
+                ADVANCE(46);
+            if (lookahead == 't')
+                ADVANCE(65);
+            if (lookahead == 'u')
+                ADVANCE(72);
+            if (lookahead == 'v')
+                ADVANCE(80);
+            if (lookahead == '{')
+                ADVANCE(100);
+            if (lookahead == '}')
+                ADVANCE(102);
+            ACCEPT_TOKEN(anon_sym_LF);
+        case ts_lex_state_error:
+            START_TOKEN();
+            if (lookahead == 0)
+                ADVANCE(2);
+            if ((lookahead == '\t') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(161);
+            if (lookahead == '\n')
+                ADVANCE(162);
+            if (lookahead == '\"')
+                ADVANCE(112);
+            if (lookahead == '#')
+                ADVANCE(3);
+            if (lookahead == '(')
+                ADVANCE(94);
+            if (lookahead == ')')
+                ADVANCE(109);
+            if (lookahead == '*')
+                ADVANCE(95);
+            if (lookahead == '+')
+                ADVANCE(125);
+            if (lookahead == ',')
+                ADVANCE(122);
+            if (lookahead == '.')
+                ADVANCE(150);
+            if (lookahead == '/')
+                ADVANCE(10);
+            if ('0' <= lookahead && lookahead <= '9')
+                ADVANCE(116);
+            if (lookahead == ';')
+                ADVANCE(141);
+            if (lookahead == '=')
+                ADVANCE(143);
             if (('A' <= lookahead && lookahead <= 'Z') ||
                 (lookahead == 'b') ||
                 (lookahead == 'd') ||
@@ -2348,151 +2403,153 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [118] = 93,
     [119] = 96,
     [120] = 129,
-    [121] = 1,
-    [122] = 93,
-    [123] = 138,
-    [124] = 140,
-    [125] = 142,
-    [126] = 107,
-    [127] = 93,
-    [128] = 142,
-    [129] = 108,
-    [130] = 142,
-    [131] = 142,
-    [132] = 111,
-    [133] = 120,
-    [134] = 121,
-    [135] = 108,
-    [136] = 142,
-    [137] = 142,
-    [138] = 124,
-    [139] = 89,
-    [140] = 93,
-    [141] = 143,
-    [142] = 1,
-    [143] = 103,
-    [144] = 144,
-    [145] = 145,
-    [146] = 138,
-    [147] = 146,
-    [148] = 146,
-    [149] = 147,
-    [150] = 149,
+    [121] = 138,
+    [122] = 1,
+    [123] = 1,
+    [124] = 93,
+    [125] = 140,
+    [126] = 142,
+    [127] = 144,
+    [128] = 107,
+    [129] = 93,
+    [130] = 144,
+    [131] = 108,
+    [132] = 144,
+    [133] = 144,
+    [134] = 111,
+    [135] = 120,
+    [136] = 121,
+    [137] = 108,
+    [138] = 144,
+    [139] = 144,
+    [140] = 124,
+    [141] = 89,
+    [142] = 93,
+    [143] = 145,
+    [144] = 1,
+    [145] = 103,
+    [146] = 146,
+    [147] = 147,
+    [148] = 140,
+    [149] = 148,
+    [150] = 148,
     [151] = 149,
-    [152] = 145,
-    [153] = 150,
-    [154] = 150,
-    [155] = 151,
-    [156] = 147,
-    [157] = 127,
-    [158] = 96,
-    [159] = 152,
-    [160] = 151,
-    [161] = 124,
-    [162] = 152,
-    [163] = 151,
-    [164] = 149,
-    [165] = 149,
-    [166] = 153,
-    [167] = 149,
-    [168] = 145,
-    [169] = 149,
-    [170] = 149,
-    [171] = 145,
-    [172] = 126,
-    [173] = 127,
-    [174] = 127,
-    [175] = 150,
-    [176] = 150,
-    [177] = 128,
-    [178] = 150,
-    [179] = 108,
-    [180] = 150,
-    [181] = 150,
-    [182] = 149,
-    [183] = 138,
-    [184] = 153,
-    [185] = 138,
-    [186] = 126,
-    [187] = 127,
-    [188] = 127,
-    [189] = 146,
-    [190] = 146,
-    [191] = 128,
-    [192] = 146,
-    [193] = 108,
-    [194] = 146,
-    [195] = 146,
-    [196] = 89,
-    [197] = 93,
-    [198] = 144,
-    [199] = 154,
-    [200] = 154,
-    [201] = 144,
-    [202] = 104,
-    [203] = 1,
-    [204] = 155,
+    [152] = 151,
+    [153] = 151,
+    [154] = 147,
+    [155] = 152,
+    [156] = 152,
+    [157] = 153,
+    [158] = 149,
+    [159] = 127,
+    [160] = 96,
+    [161] = 154,
+    [162] = 153,
+    [163] = 124,
+    [164] = 154,
+    [165] = 153,
+    [166] = 151,
+    [167] = 151,
+    [168] = 155,
+    [169] = 151,
+    [170] = 147,
+    [171] = 151,
+    [172] = 151,
+    [173] = 147,
+    [174] = 126,
+    [175] = 127,
+    [176] = 127,
+    [177] = 152,
+    [178] = 152,
+    [179] = 128,
+    [180] = 152,
+    [181] = 108,
+    [182] = 152,
+    [183] = 152,
+    [184] = 151,
+    [185] = 140,
+    [186] = 155,
+    [187] = 140,
+    [188] = 126,
+    [189] = 127,
+    [190] = 127,
+    [191] = 148,
+    [192] = 148,
+    [193] = 128,
+    [194] = 148,
+    [195] = 108,
+    [196] = 148,
+    [197] = 148,
+    [198] = 89,
+    [199] = 93,
+    [200] = 146,
+    [201] = 156,
+    [202] = 156,
+    [203] = 146,
+    [204] = 104,
     [205] = 1,
-    [206] = 144,
-    [207] = 126,
-    [208] = 127,
-    [209] = 127,
-    [210] = 154,
-    [211] = 154,
-    [212] = 128,
-    [213] = 154,
-    [214] = 108,
-    [215] = 154,
-    [216] = 154,
-    [217] = 104,
-    [218] = 138,
-    [219] = 156,
-    [220] = 157,
-    [221] = 107,
-    [222] = 93,
-    [223] = 157,
-    [224] = 108,
-    [225] = 157,
-    [226] = 157,
-    [227] = 111,
-    [228] = 120,
-    [229] = 121,
-    [230] = 108,
-    [231] = 157,
-    [232] = 157,
-    [233] = 124,
-    [234] = 158,
-    [235] = 93,
-    [236] = 144,
-    [237] = 138,
-    [238] = 158,
-    [239] = 144,
-    [240] = 93,
-    [241] = 138,
-    [242] = 158,
-    [243] = 144,
-    [244] = 1,
-    [245] = 103,
-    [246] = 138,
-    [247] = 158,
-    [248] = 143,
-    [249] = 143,
-    [250] = 93,
-    [251] = 138,
-    [252] = 158,
-    [253] = 143,
-    [254] = 158,
-    [255] = 1,
-    [256] = 1,
-    [257] = 89,
-    [258] = 93,
-    [259] = 138,
-    [260] = 140,
-    [261] = 103,
-    [262] = 1,
-    [263] = 158,
+    [206] = 157,
+    [207] = 1,
+    [208] = 146,
+    [209] = 126,
+    [210] = 127,
+    [211] = 127,
+    [212] = 156,
+    [213] = 156,
+    [214] = 128,
+    [215] = 156,
+    [216] = 108,
+    [217] = 156,
+    [218] = 156,
+    [219] = 104,
+    [220] = 140,
+    [221] = 158,
+    [222] = 159,
+    [223] = 107,
+    [224] = 93,
+    [225] = 159,
+    [226] = 108,
+    [227] = 159,
+    [228] = 159,
+    [229] = 111,
+    [230] = 120,
+    [231] = 121,
+    [232] = 108,
+    [233] = 159,
+    [234] = 159,
+    [235] = 124,
+    [236] = 160,
+    [237] = 93,
+    [238] = 146,
+    [239] = 140,
+    [240] = 160,
+    [241] = 146,
+    [242] = 93,
+    [243] = 140,
+    [244] = 160,
+    [245] = 146,
+    [246] = 1,
+    [247] = 103,
+    [248] = 140,
+    [249] = 160,
+    [250] = 145,
+    [251] = 145,
+    [252] = 93,
+    [253] = 140,
+    [254] = 160,
+    [255] = 145,
+    [256] = 160,
+    [257] = 1,
+    [258] = 1,
+    [259] = 89,
+    [260] = 93,
+    [261] = 140,
+    [262] = 142,
+    [263] = 103,
     [264] = 1,
-    [265] = 88,
+    [265] = 160,
+    [266] = 1,
+    [267] = 88,
 };
 
 #pragma GCC diagnostic push
@@ -2545,7 +2602,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
         [sym_declaration] = ACTIONS(SHIFT(2)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(265)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(267)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
@@ -2567,7 +2624,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [3] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(258)),
+        [sym__type_specifier] = ACTIONS(SHIFT(260)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
@@ -2585,7 +2642,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_name] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
         [sym_struct_specifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(257)),
+        [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(259)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
         [anon_sym_typedef] = ACTIONS(SHIFT(11)),
         [anon_sym_extern] = ACTIONS(SHIFT(11)),
@@ -2604,14 +2661,14 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [5] = {
-        [sym__init_declarator] = ACTIONS(SHIFT(123)),
-        [sym_declarator] = ACTIONS(SHIFT(124)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(125)),
+        [sym__init_declarator] = ACTIONS(SHIFT(125)),
+        [sym_declarator] = ACTIONS(SHIFT(126)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(127)),
         [sym_pointer] = ACTIONS(SHIFT(40)),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(126)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(127)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(128)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(129)),
         [anon_sym_STAR] = ACTIONS(SHIFT(43)),
-        [sym_identifier] = ACTIONS(SHIFT(128)),
+        [sym_identifier] = ACTIONS(SHIFT(130)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [6] = {
@@ -2643,7 +2700,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [9] = {
-        [sym_identifier] = ACTIONS(SHIFT(122)),
+        [sym_identifier] = ACTIONS(SHIFT(124)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [10] = {
@@ -3683,10 +3740,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [120] = {
-        [aux_sym_SLASH_LPAREN_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_PIPE_RPAREN_SLASH] = ACTIONS(SHIFT(121)),
+        [aux_sym_SLASH_LPAREN_BSLASH_LF_PIPE_DOT_RPAREN_STAR_SLASH] = ACTIONS(SHIFT(121)),
+        [anon_sym_LF] = ACTIONS(SHIFT(122)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [121] = {
+        [anon_sym_LF] = ACTIONS(SHIFT(123)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [122] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_preproc_define, 3)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_preproc_define, 3)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_preproc_define, 3)),
@@ -3717,7 +3779,38 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_preproc_define, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [122] = {
+    [123] = {
+        [sym_preproc_define] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_function_definition] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym__type_specifier] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_type_name] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_declaration] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_type_qualifier] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [aux_sym_declaration_specifiers_repeat1] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_POUNDdefine] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_typedef] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_extern] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_static] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_auto] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_register] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_signed] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_unsigned] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_long] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_short] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_struct] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_const] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_restrict] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [anon_sym_volatile] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_preproc_define, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [124] = {
         [sym__init_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
         [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
@@ -3728,22 +3821,22 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [123] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(254)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(235)),
-        [anon_sym_SEMI] = ACTIONS(SHIFT(255)),
+    [125] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(256)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(237)),
+        [anon_sym_SEMI] = ACTIONS(SHIFT(257)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [124] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(139)),
+    [126] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(141)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(140)),
+        [sym__type_specifier] = ACTIONS(SHIFT(142)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_declaration] = ACTIONS(SHIFT(141)),
+        [sym_declaration] = ACTIONS(SHIFT(143)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_compound_statement] = ACTIONS(SHIFT(142)),
-        [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(143)),
+        [sym_compound_statement] = ACTIONS(SHIFT(144)),
+        [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(145)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 1)),
@@ -3757,17 +3850,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_long] = ACTIONS(SHIFT(12)),
         [anon_sym_short] = ACTIONS(SHIFT(12)),
         [anon_sym_struct] = ACTIONS(SHIFT(13)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(144)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(146)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [anon_sym_EQ] = ACTIONS(SHIFT(145)),
+        [anon_sym_EQ] = ACTIONS(SHIFT(147)),
         [anon_sym_const] = ACTIONS(SHIFT(14)),
         [anon_sym_restrict] = ACTIONS(SHIFT(14)),
         [anon_sym_volatile] = ACTIONS(SHIFT(14)),
         [sym_identifier] = ACTIONS(SHIFT(15)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [125] = {
+    [127] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declarator, 1)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declarator, 1)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declarator, 1)),
@@ -3794,22 +3887,22 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 1)),
         [anon_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(132)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(133)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(134)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(135)),
         [anon_sym_const] = ACTIONS(REDUCE(sym_declarator, 1)),
         [anon_sym_restrict] = ACTIONS(REDUCE(sym_declarator, 1)),
         [anon_sym_volatile] = ACTIONS(REDUCE(sym_declarator, 1)),
         [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [126] = {
-        [sym__direct_declarator] = ACTIONS(SHIFT(131)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(127)),
-        [sym_identifier] = ACTIONS(SHIFT(128)),
+    [128] = {
+        [sym__direct_declarator] = ACTIONS(SHIFT(133)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(129)),
+        [sym_identifier] = ACTIONS(SHIFT(130)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [127] = {
-        [sym_declarator] = ACTIONS(SHIFT(129)),
+    [129] = {
+        [sym_declarator] = ACTIONS(SHIFT(131)),
         [sym__direct_declarator] = ACTIONS(SHIFT(46)),
         [sym_pointer] = ACTIONS(SHIFT(40)),
         [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(47)),
@@ -3818,7 +3911,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(SHIFT(49)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [128] = {
+    [130] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
@@ -3853,11 +3946,11 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [129] = {
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(130)),
+    [131] = {
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(132)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [130] = {
+    [132] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
@@ -3892,7 +3985,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [131] = {
+    [133] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declarator, 2)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declarator, 2)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declarator, 2)),
@@ -3919,31 +4012,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 2)),
         [anon_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(132)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(133)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(134)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(135)),
         [anon_sym_const] = ACTIONS(REDUCE(sym_declarator, 2)),
         [anon_sym_restrict] = ACTIONS(REDUCE(sym_declarator, 2)),
         [anon_sym_volatile] = ACTIONS(REDUCE(sym_declarator, 2)),
         [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [132] = {
-        [sym_expression] = ACTIONS(SHIFT(138)),
+    [134] = {
+        [sym_expression] = ACTIONS(SHIFT(140)),
         [sym_math_expression] = ACTIONS(SHIFT(79)),
         [sym_call_expression] = ACTIONS(SHIFT(79)),
-        [anon_sym_RBRACK] = ACTIONS(SHIFT(130)),
+        [anon_sym_RBRACK] = ACTIONS(SHIFT(132)),
         [sym_string] = ACTIONS(SHIFT(79)),
         [sym_identifier] = ACTIONS(SHIFT(79)),
         [sym_number] = ACTIONS(SHIFT(79)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [133] = {
+    [135] = {
         [sym_declaration_specifiers] = ACTIONS(SHIFT(55)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
         [sym__type_specifier] = ACTIONS(SHIFT(56)),
         [sym_type_name] = ACTIONS(SHIFT(20)),
         [sym_struct_specifier] = ACTIONS(SHIFT(20)),
-        [sym_parameter_declaration] = ACTIONS(SHIFT(134)),
+        [sym_parameter_declaration] = ACTIONS(SHIFT(136)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(22)),
@@ -3957,24 +4050,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_long] = ACTIONS(SHIFT(12)),
         [anon_sym_short] = ACTIONS(SHIFT(12)),
         [anon_sym_struct] = ACTIONS(SHIFT(24)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(130)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(132)),
         [anon_sym_const] = ACTIONS(SHIFT(14)),
         [anon_sym_restrict] = ACTIONS(SHIFT(14)),
         [anon_sym_volatile] = ACTIONS(SHIFT(14)),
         [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [134] = {
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(135)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(59)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(136)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [135] = {
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(137)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [136] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(137)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(59)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(138)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [137] = {
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(139)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [138] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
@@ -4009,7 +4102,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [137] = {
+    [139] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
@@ -4044,15 +4137,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [138] = {
-        [anon_sym_RBRACK] = ACTIONS(SHIFT(136)),
+    [140] = {
+        [anon_sym_RBRACK] = ACTIONS(SHIFT(138)),
         [anon_sym_LPAREN] = ACTIONS(SHIFT(80)),
         [anon_sym_STAR] = ACTIONS(SHIFT(81)),
         [anon_sym_PLUS] = ACTIONS(SHIFT(82)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [139] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(250)),
+    [141] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(252)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
@@ -4064,27 +4157,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(SHIFT(15)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [140] = {
-        [sym__init_declarator] = ACTIONS(SHIFT(246)),
-        [sym_declarator] = ACTIONS(SHIFT(219)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(220)),
+    [142] = {
+        [sym__init_declarator] = ACTIONS(SHIFT(248)),
+        [sym_declarator] = ACTIONS(SHIFT(221)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(222)),
         [sym_pointer] = ACTIONS(SHIFT(40)),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(221)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(222)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(223)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(224)),
         [anon_sym_STAR] = ACTIONS(SHIFT(43)),
-        [sym_identifier] = ACTIONS(SHIFT(223)),
+        [sym_identifier] = ACTIONS(SHIFT(225)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [141] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(139)),
+    [143] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(141)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(140)),
+        [sym__type_specifier] = ACTIONS(SHIFT(142)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_declaration] = ACTIONS(SHIFT(141)),
+        [sym_declaration] = ACTIONS(SHIFT(143)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
         [sym_compound_statement] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 1)),
-        [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(245)),
+        [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(247)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
         [anon_sym_typedef] = ACTIONS(SHIFT(11)),
@@ -4104,7 +4197,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(SHIFT(15)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [142] = {
+    [144] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_function_definition, 3)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_function_definition, 3)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_function_definition, 3)),
@@ -4135,28 +4228,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_function_definition, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [143] = {
-        [sym_compound_statement] = ACTIONS(SHIFT(244)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(144)),
+    [145] = {
+        [sym_compound_statement] = ACTIONS(SHIFT(246)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(146)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [144] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(196)),
+    [146] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(198)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(197)),
+        [sym__type_specifier] = ACTIONS(SHIFT(199)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_declaration] = ACTIONS(SHIFT(198)),
+        [sym_declaration] = ACTIONS(SHIFT(200)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_expression] = ACTIONS(SHIFT(199)),
-        [sym_math_expression] = ACTIONS(SHIFT(200)),
-        [sym_call_expression] = ACTIONS(SHIFT(200)),
-        [sym_statement] = ACTIONS(SHIFT(198)),
-        [sym_expression_statement] = ACTIONS(SHIFT(201)),
+        [sym_expression] = ACTIONS(SHIFT(201)),
+        [sym_math_expression] = ACTIONS(SHIFT(202)),
+        [sym_call_expression] = ACTIONS(SHIFT(202)),
+        [sym_statement] = ACTIONS(SHIFT(200)),
+        [sym_expression_statement] = ACTIONS(SHIFT(203)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(202)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(202)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(204)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(204)),
         [anon_sym_typedef] = ACTIONS(SHIFT(11)),
         [anon_sym_extern] = ACTIONS(SHIFT(11)),
         [anon_sym_static] = ACTIONS(SHIFT(11)),
@@ -4167,42 +4260,42 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_long] = ACTIONS(SHIFT(12)),
         [anon_sym_short] = ACTIONS(SHIFT(12)),
         [anon_sym_struct] = ACTIONS(SHIFT(13)),
-        [anon_sym_RBRACE] = ACTIONS(SHIFT(203)),
+        [anon_sym_RBRACE] = ACTIONS(SHIFT(205)),
         [anon_sym_const] = ACTIONS(SHIFT(14)),
         [anon_sym_restrict] = ACTIONS(SHIFT(14)),
         [anon_sym_volatile] = ACTIONS(SHIFT(14)),
-        [sym_string] = ACTIONS(SHIFT(200)),
-        [sym_identifier] = ACTIONS(SHIFT(204)),
-        [sym_number] = ACTIONS(SHIFT(200)),
+        [sym_string] = ACTIONS(SHIFT(202)),
+        [sym_identifier] = ACTIONS(SHIFT(206)),
+        [sym_number] = ACTIONS(SHIFT(202)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [145] = {
-        [sym_initializer] = ACTIONS(SHIFT(146)),
-        [sym_expression] = ACTIONS(SHIFT(147)),
-        [sym_math_expression] = ACTIONS(SHIFT(148)),
-        [sym_call_expression] = ACTIONS(SHIFT(148)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(149)),
-        [sym_string] = ACTIONS(SHIFT(148)),
-        [sym_identifier] = ACTIONS(SHIFT(148)),
-        [sym_number] = ACTIONS(SHIFT(148)),
+    [147] = {
+        [sym_initializer] = ACTIONS(SHIFT(148)),
+        [sym_expression] = ACTIONS(SHIFT(149)),
+        [sym_math_expression] = ACTIONS(SHIFT(150)),
+        [sym_call_expression] = ACTIONS(SHIFT(150)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(151)),
+        [sym_string] = ACTIONS(SHIFT(150)),
+        [sym_identifier] = ACTIONS(SHIFT(150)),
+        [sym_number] = ACTIONS(SHIFT(150)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [146] = {
+    [148] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 3)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [147] = {
+    [149] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_initializer, 1)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(186)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(187)),
-        [anon_sym_PLUS] = ACTIONS(SHIFT(188)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(188)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(189)),
+        [anon_sym_PLUS] = ACTIONS(SHIFT(190)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [148] = {
+    [150] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_expression, 1)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
@@ -4211,52 +4304,52 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [149] = {
-        [sym_initializer] = ACTIONS(SHIFT(150)),
-        [sym_initializer_list] = ACTIONS(SHIFT(151)),
-        [sym_designation] = ACTIONS(SHIFT(152)),
-        [sym_expression] = ACTIONS(SHIFT(153)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(155)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(156)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(157)),
-        [anon_sym_DOT] = ACTIONS(SHIFT(158)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
+    [151] = {
+        [sym_initializer] = ACTIONS(SHIFT(152)),
+        [sym_initializer_list] = ACTIONS(SHIFT(153)),
+        [sym_designation] = ACTIONS(SHIFT(154)),
+        [sym_expression] = ACTIONS(SHIFT(155)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(157)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(158)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(159)),
+        [anon_sym_DOT] = ACTIONS(SHIFT(160)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [150] = {
+    [152] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 1)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [151] = {
-        [anon_sym_RBRACE] = ACTIONS(SHIFT(183)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(184)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [152] = {
-        [sym_initializer] = ACTIONS(SHIFT(182)),
-        [sym_expression] = ACTIONS(SHIFT(153)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(156)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [153] = {
-        [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(172)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(173)),
-        [anon_sym_PLUS] = ACTIONS(SHIFT(174)),
+        [anon_sym_RBRACE] = ACTIONS(SHIFT(185)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(186)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [154] = {
+        [sym_initializer] = ACTIONS(SHIFT(184)),
+        [sym_expression] = ACTIONS(SHIFT(155)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(158)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [155] = {
+        [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer, 1)),
+        [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 1)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(174)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(175)),
+        [anon_sym_PLUS] = ACTIONS(SHIFT(176)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [156] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_expression, 1)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
@@ -4264,28 +4357,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [155] = {
-        [anon_sym_EQ] = ACTIONS(SHIFT(171)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [156] = {
-        [sym_initializer] = ACTIONS(SHIFT(150)),
-        [sym_initializer_list] = ACTIONS(SHIFT(164)),
-        [sym_designation] = ACTIONS(SHIFT(152)),
-        [sym_expression] = ACTIONS(SHIFT(153)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(155)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(156)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(157)),
-        [anon_sym_DOT] = ACTIONS(SHIFT(158)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [157] = {
-        [sym_expression] = ACTIONS(SHIFT(161)),
+        [anon_sym_EQ] = ACTIONS(SHIFT(173)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [158] = {
+        [sym_initializer] = ACTIONS(SHIFT(152)),
+        [sym_initializer_list] = ACTIONS(SHIFT(166)),
+        [sym_designation] = ACTIONS(SHIFT(154)),
+        [sym_expression] = ACTIONS(SHIFT(155)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(157)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(158)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(159)),
+        [anon_sym_DOT] = ACTIONS(SHIFT(160)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [159] = {
+        [sym_expression] = ACTIONS(SHIFT(163)),
         [sym_math_expression] = ACTIONS(SHIFT(79)),
         [sym_call_expression] = ACTIONS(SHIFT(79)),
         [sym_string] = ACTIONS(SHIFT(79)),
@@ -4293,92 +4386,92 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_number] = ACTIONS(SHIFT(79)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [158] = {
-        [sym_identifier] = ACTIONS(SHIFT(159)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [159] = {
-        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(160)),
-        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 2)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(157)),
-        [anon_sym_DOT] = ACTIONS(SHIFT(158)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [160] = {
-        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
+        [sym_identifier] = ACTIONS(SHIFT(161)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [161] = {
-        [anon_sym_RBRACK] = ACTIONS(SHIFT(162)),
+        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(162)),
+        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 2)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(159)),
+        [anon_sym_DOT] = ACTIONS(SHIFT(160)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [162] = {
+        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [163] = {
+        [anon_sym_RBRACK] = ACTIONS(SHIFT(164)),
         [anon_sym_LPAREN] = ACTIONS(SHIFT(80)),
         [anon_sym_STAR] = ACTIONS(SHIFT(81)),
         [anon_sym_PLUS] = ACTIONS(SHIFT(82)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [162] = {
-        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(163)),
-        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(157)),
-        [anon_sym_DOT] = ACTIONS(SHIFT(158)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [163] = {
-        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [164] = {
-        [anon_sym_RBRACE] = ACTIONS(SHIFT(165)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(166)),
+        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(165)),
+        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(159)),
+        [anon_sym_DOT] = ACTIONS(SHIFT(160)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [165] = {
+        [anon_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [166] = {
+        [anon_sym_RBRACE] = ACTIONS(SHIFT(167)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(168)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [167] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [166] = {
-        [sym_initializer] = ACTIONS(SHIFT(167)),
-        [sym_designation] = ACTIONS(SHIFT(168)),
-        [sym_expression] = ACTIONS(SHIFT(153)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(155)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(156)),
-        [anon_sym_RBRACE] = ACTIONS(SHIFT(169)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(157)),
-        [anon_sym_DOT] = ACTIONS(SHIFT(158)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
+    [168] = {
+        [sym_initializer] = ACTIONS(SHIFT(169)),
+        [sym_designation] = ACTIONS(SHIFT(170)),
+        [sym_expression] = ACTIONS(SHIFT(155)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(157)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(158)),
+        [anon_sym_RBRACE] = ACTIONS(SHIFT(171)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(159)),
+        [anon_sym_DOT] = ACTIONS(SHIFT(160)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [167] = {
+    [169] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [168] = {
-        [sym_initializer] = ACTIONS(SHIFT(170)),
-        [sym_expression] = ACTIONS(SHIFT(153)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(156)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
+    [170] = {
+        [sym_initializer] = ACTIONS(SHIFT(172)),
+        [sym_expression] = ACTIONS(SHIFT(155)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(158)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [169] = {
+    [171] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer, 4)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [170] = {
+    [172] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 4)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [171] = {
+    [173] = {
         [sym_initializer] = ACTIONS(REDUCE(sym_designation, 2)),
         [sym_expression] = ACTIONS(REDUCE(sym_designation, 2)),
         [sym_math_expression] = ACTIONS(REDUCE(sym_designation, 2)),
@@ -4389,60 +4482,60 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_number] = ACTIONS(REDUCE(sym_designation, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [172] = {
-        [sym_expression] = ACTIONS(SHIFT(177)),
+    [174] = {
+        [sym_expression] = ACTIONS(SHIFT(179)),
         [sym_math_expression] = ACTIONS(SHIFT(86)),
         [sym_call_expression] = ACTIONS(SHIFT(86)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(178)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(180)),
         [sym_string] = ACTIONS(SHIFT(86)),
         [sym_identifier] = ACTIONS(SHIFT(86)),
         [sym_number] = ACTIONS(SHIFT(86)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [173] = {
-        [sym_expression] = ACTIONS(SHIFT(176)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [174] = {
-        [sym_expression] = ACTIONS(SHIFT(175)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [175] = {
-        [anon_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(172)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(173)),
-        [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_expression] = ACTIONS(SHIFT(178)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [176] = {
+        [sym_expression] = ACTIONS(SHIFT(177)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [177] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(172)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(174)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(175)),
+        [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [178] = {
+        [anon_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [anon_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(174)),
         [anon_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [177] = {
-        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(179)),
+    [179] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(181)),
         [anon_sym_COMMA] = ACTIONS(SHIFT(89)),
         [anon_sym_LPAREN] = ACTIONS(SHIFT(90)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(180)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(182)),
         [anon_sym_STAR] = ACTIONS(SHIFT(92)),
         [anon_sym_PLUS] = ACTIONS(SHIFT(93)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [178] = {
+    [180] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
@@ -4450,11 +4543,11 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [179] = {
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(181)),
+    [181] = {
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(183)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [180] = {
+    [182] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
@@ -4462,7 +4555,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [181] = {
+    [183] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
@@ -4470,95 +4563,95 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [182] = {
+    [184] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 2)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [183] = {
+    [185] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_initializer, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 3)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_initializer, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [184] = {
-        [sym_initializer] = ACTIONS(SHIFT(167)),
-        [sym_designation] = ACTIONS(SHIFT(168)),
-        [sym_expression] = ACTIONS(SHIFT(153)),
-        [sym_math_expression] = ACTIONS(SHIFT(154)),
-        [sym_call_expression] = ACTIONS(SHIFT(154)),
-        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(155)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(156)),
-        [anon_sym_RBRACE] = ACTIONS(SHIFT(185)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(157)),
-        [anon_sym_DOT] = ACTIONS(SHIFT(158)),
-        [sym_string] = ACTIONS(SHIFT(154)),
-        [sym_identifier] = ACTIONS(SHIFT(154)),
-        [sym_number] = ACTIONS(SHIFT(154)),
+    [186] = {
+        [sym_initializer] = ACTIONS(SHIFT(169)),
+        [sym_designation] = ACTIONS(SHIFT(170)),
+        [sym_expression] = ACTIONS(SHIFT(155)),
+        [sym_math_expression] = ACTIONS(SHIFT(156)),
+        [sym_call_expression] = ACTIONS(SHIFT(156)),
+        [aux_sym_designation_repeat1] = ACTIONS(SHIFT(157)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(158)),
+        [anon_sym_RBRACE] = ACTIONS(SHIFT(187)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(159)),
+        [anon_sym_DOT] = ACTIONS(SHIFT(160)),
+        [sym_string] = ACTIONS(SHIFT(156)),
+        [sym_identifier] = ACTIONS(SHIFT(156)),
+        [sym_number] = ACTIONS(SHIFT(156)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [185] = {
+    [187] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_initializer, 4)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 4)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_initializer, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [186] = {
-        [sym_expression] = ACTIONS(SHIFT(191)),
+    [188] = {
+        [sym_expression] = ACTIONS(SHIFT(193)),
         [sym_math_expression] = ACTIONS(SHIFT(86)),
         [sym_call_expression] = ACTIONS(SHIFT(86)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(192)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(194)),
         [sym_string] = ACTIONS(SHIFT(86)),
         [sym_identifier] = ACTIONS(SHIFT(86)),
         [sym_number] = ACTIONS(SHIFT(86)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [187] = {
-        [sym_expression] = ACTIONS(SHIFT(190)),
-        [sym_math_expression] = ACTIONS(SHIFT(148)),
-        [sym_call_expression] = ACTIONS(SHIFT(148)),
-        [sym_string] = ACTIONS(SHIFT(148)),
-        [sym_identifier] = ACTIONS(SHIFT(148)),
-        [sym_number] = ACTIONS(SHIFT(148)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [188] = {
-        [sym_expression] = ACTIONS(SHIFT(189)),
-        [sym_math_expression] = ACTIONS(SHIFT(148)),
-        [sym_call_expression] = ACTIONS(SHIFT(148)),
-        [sym_string] = ACTIONS(SHIFT(148)),
-        [sym_identifier] = ACTIONS(SHIFT(148)),
-        [sym_number] = ACTIONS(SHIFT(148)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [189] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(186)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(187)),
-        [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_expression] = ACTIONS(SHIFT(192)),
+        [sym_math_expression] = ACTIONS(SHIFT(150)),
+        [sym_call_expression] = ACTIONS(SHIFT(150)),
+        [sym_string] = ACTIONS(SHIFT(150)),
+        [sym_identifier] = ACTIONS(SHIFT(150)),
+        [sym_number] = ACTIONS(SHIFT(150)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [190] = {
+        [sym_expression] = ACTIONS(SHIFT(191)),
+        [sym_math_expression] = ACTIONS(SHIFT(150)),
+        [sym_call_expression] = ACTIONS(SHIFT(150)),
+        [sym_string] = ACTIONS(SHIFT(150)),
+        [sym_identifier] = ACTIONS(SHIFT(150)),
+        [sym_number] = ACTIONS(SHIFT(150)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [191] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [anon_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(186)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(188)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(189)),
+        [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [192] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [anon_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [anon_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(188)),
         [anon_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [191] = {
-        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(193)),
+    [193] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(195)),
         [anon_sym_COMMA] = ACTIONS(SHIFT(89)),
         [anon_sym_LPAREN] = ACTIONS(SHIFT(90)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(194)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(196)),
         [anon_sym_STAR] = ACTIONS(SHIFT(92)),
         [anon_sym_PLUS] = ACTIONS(SHIFT(93)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [192] = {
+    [194] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
@@ -4567,11 +4660,11 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [193] = {
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(195)),
+    [195] = {
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(197)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [194] = {
+    [196] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
@@ -4580,7 +4673,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [195] = {
+    [197] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
@@ -4589,8 +4682,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [196] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(240)),
+    [198] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(242)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
@@ -4602,33 +4695,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(SHIFT(15)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [197] = {
-        [sym__init_declarator] = ACTIONS(SHIFT(218)),
-        [sym_declarator] = ACTIONS(SHIFT(219)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(220)),
+    [199] = {
+        [sym__init_declarator] = ACTIONS(SHIFT(220)),
+        [sym_declarator] = ACTIONS(SHIFT(221)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(222)),
         [sym_pointer] = ACTIONS(SHIFT(40)),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(221)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(222)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(223)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(224)),
         [anon_sym_STAR] = ACTIONS(SHIFT(43)),
-        [sym_identifier] = ACTIONS(SHIFT(223)),
+        [sym_identifier] = ACTIONS(SHIFT(225)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [198] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(196)),
+    [200] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(198)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(197)),
+        [sym__type_specifier] = ACTIONS(SHIFT(199)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_declaration] = ACTIONS(SHIFT(198)),
+        [sym_declaration] = ACTIONS(SHIFT(200)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_expression] = ACTIONS(SHIFT(199)),
-        [sym_math_expression] = ACTIONS(SHIFT(200)),
-        [sym_call_expression] = ACTIONS(SHIFT(200)),
-        [sym_statement] = ACTIONS(SHIFT(198)),
-        [sym_expression_statement] = ACTIONS(SHIFT(201)),
+        [sym_expression] = ACTIONS(SHIFT(201)),
+        [sym_math_expression] = ACTIONS(SHIFT(202)),
+        [sym_call_expression] = ACTIONS(SHIFT(202)),
+        [sym_statement] = ACTIONS(SHIFT(200)),
+        [sym_expression_statement] = ACTIONS(SHIFT(203)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(217)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(219)),
         [anon_sym_typedef] = ACTIONS(SHIFT(11)),
         [anon_sym_extern] = ACTIONS(SHIFT(11)),
         [anon_sym_static] = ACTIONS(SHIFT(11)),
@@ -4643,26 +4736,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_const] = ACTIONS(SHIFT(14)),
         [anon_sym_restrict] = ACTIONS(SHIFT(14)),
         [anon_sym_volatile] = ACTIONS(SHIFT(14)),
-        [sym_string] = ACTIONS(SHIFT(200)),
-        [sym_identifier] = ACTIONS(SHIFT(204)),
-        [sym_number] = ACTIONS(SHIFT(200)),
+        [sym_string] = ACTIONS(SHIFT(202)),
+        [sym_identifier] = ACTIONS(SHIFT(206)),
+        [sym_number] = ACTIONS(SHIFT(202)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [199] = {
-        [anon_sym_SEMI] = ACTIONS(SHIFT(206)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(207)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(208)),
-        [anon_sym_PLUS] = ACTIONS(SHIFT(209)),
+    [201] = {
+        [anon_sym_SEMI] = ACTIONS(SHIFT(208)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(209)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(210)),
+        [anon_sym_PLUS] = ACTIONS(SHIFT(211)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [200] = {
+    [202] = {
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
         [anon_sym_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [201] = {
+    [203] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_statement, 1)),
@@ -4697,11 +4790,11 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_number] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [202] = {
-        [anon_sym_RBRACE] = ACTIONS(SHIFT(205)),
+    [204] = {
+        [anon_sym_RBRACE] = ACTIONS(SHIFT(207)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [203] = {
+    [205] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_compound_statement, 2)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_compound_statement, 2)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_compound_statement, 2)),
@@ -4732,7 +4825,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_compound_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [204] = {
+    [206] = {
         [sym__init_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
@@ -4745,7 +4838,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [205] = {
+    [207] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_compound_statement, 3)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_compound_statement, 3)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_compound_statement, 3)),
@@ -4776,7 +4869,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_compound_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [206] = {
+    [208] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -4811,116 +4904,116 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_number] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [207] = {
-        [sym_expression] = ACTIONS(SHIFT(212)),
+    [209] = {
+        [sym_expression] = ACTIONS(SHIFT(214)),
         [sym_math_expression] = ACTIONS(SHIFT(86)),
         [sym_call_expression] = ACTIONS(SHIFT(86)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(213)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(215)),
         [sym_string] = ACTIONS(SHIFT(86)),
         [sym_identifier] = ACTIONS(SHIFT(86)),
         [sym_number] = ACTIONS(SHIFT(86)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [208] = {
-        [sym_expression] = ACTIONS(SHIFT(211)),
-        [sym_math_expression] = ACTIONS(SHIFT(200)),
-        [sym_call_expression] = ACTIONS(SHIFT(200)),
-        [sym_string] = ACTIONS(SHIFT(200)),
-        [sym_identifier] = ACTIONS(SHIFT(200)),
-        [sym_number] = ACTIONS(SHIFT(200)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [209] = {
-        [sym_expression] = ACTIONS(SHIFT(210)),
-        [sym_math_expression] = ACTIONS(SHIFT(200)),
-        [sym_call_expression] = ACTIONS(SHIFT(200)),
-        [sym_string] = ACTIONS(SHIFT(200)),
-        [sym_identifier] = ACTIONS(SHIFT(200)),
-        [sym_number] = ACTIONS(SHIFT(200)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [210] = {
-        [anon_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(207)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(208)),
-        [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_expression] = ACTIONS(SHIFT(213)),
+        [sym_math_expression] = ACTIONS(SHIFT(202)),
+        [sym_call_expression] = ACTIONS(SHIFT(202)),
+        [sym_string] = ACTIONS(SHIFT(202)),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym_number] = ACTIONS(SHIFT(202)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [211] = {
+        [sym_expression] = ACTIONS(SHIFT(212)),
+        [sym_math_expression] = ACTIONS(SHIFT(202)),
+        [sym_call_expression] = ACTIONS(SHIFT(202)),
+        [sym_string] = ACTIONS(SHIFT(202)),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym_number] = ACTIONS(SHIFT(202)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [212] = {
         [anon_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(207)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(209)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(210)),
+        [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [213] = {
+        [anon_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(209)),
         [anon_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [212] = {
-        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(214)),
+    [214] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(216)),
         [anon_sym_COMMA] = ACTIONS(SHIFT(89)),
         [anon_sym_LPAREN] = ACTIONS(SHIFT(90)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(215)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(217)),
         [anon_sym_STAR] = ACTIONS(SHIFT(92)),
         [anon_sym_PLUS] = ACTIONS(SHIFT(93)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [213] = {
+    [215] = {
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [anon_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [214] = {
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(216)),
+    [216] = {
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(218)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [215] = {
+    [217] = {
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [anon_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [216] = {
+    [218] = {
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [anon_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [anon_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [217] = {
+    [219] = {
         [anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_compound_statement_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [218] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(234)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(235)),
-        [anon_sym_SEMI] = ACTIONS(SHIFT(236)),
+    [220] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(236)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(237)),
+        [anon_sym_SEMI] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [219] = {
+    [221] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 1)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [anon_sym_EQ] = ACTIONS(SHIFT(145)),
+        [anon_sym_EQ] = ACTIONS(SHIFT(147)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [220] = {
+    [222] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 1)),
         [anon_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(227)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(228)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(229)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(230)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [221] = {
-        [sym__direct_declarator] = ACTIONS(SHIFT(226)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(222)),
-        [sym_identifier] = ACTIONS(SHIFT(223)),
+    [223] = {
+        [sym__direct_declarator] = ACTIONS(SHIFT(228)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(224)),
+        [sym_identifier] = ACTIONS(SHIFT(225)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [222] = {
-        [sym_declarator] = ACTIONS(SHIFT(224)),
+    [224] = {
+        [sym_declarator] = ACTIONS(SHIFT(226)),
         [sym__direct_declarator] = ACTIONS(SHIFT(46)),
         [sym_pointer] = ACTIONS(SHIFT(40)),
         [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(47)),
@@ -4929,7 +5022,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(SHIFT(49)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [223] = {
+    [225] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
@@ -4938,11 +5031,11 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [224] = {
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(225)),
+    [226] = {
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(227)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [225] = {
+    [227] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
@@ -4951,32 +5044,32 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [226] = {
+    [228] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 2)),
         [anon_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [anon_sym_LBRACK] = ACTIONS(SHIFT(227)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(228)),
+        [anon_sym_LBRACK] = ACTIONS(SHIFT(229)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(230)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [227] = {
-        [sym_expression] = ACTIONS(SHIFT(233)),
+    [229] = {
+        [sym_expression] = ACTIONS(SHIFT(235)),
         [sym_math_expression] = ACTIONS(SHIFT(79)),
         [sym_call_expression] = ACTIONS(SHIFT(79)),
-        [anon_sym_RBRACK] = ACTIONS(SHIFT(225)),
+        [anon_sym_RBRACK] = ACTIONS(SHIFT(227)),
         [sym_string] = ACTIONS(SHIFT(79)),
         [sym_identifier] = ACTIONS(SHIFT(79)),
         [sym_number] = ACTIONS(SHIFT(79)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [228] = {
+    [230] = {
         [sym_declaration_specifiers] = ACTIONS(SHIFT(55)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
         [sym__type_specifier] = ACTIONS(SHIFT(56)),
         [sym_type_name] = ACTIONS(SHIFT(20)),
         [sym_struct_specifier] = ACTIONS(SHIFT(20)),
-        [sym_parameter_declaration] = ACTIONS(SHIFT(229)),
+        [sym_parameter_declaration] = ACTIONS(SHIFT(231)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(22)),
@@ -4990,24 +5083,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_long] = ACTIONS(SHIFT(12)),
         [anon_sym_short] = ACTIONS(SHIFT(12)),
         [anon_sym_struct] = ACTIONS(SHIFT(24)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(225)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(227)),
         [anon_sym_const] = ACTIONS(SHIFT(14)),
         [anon_sym_restrict] = ACTIONS(SHIFT(14)),
         [anon_sym_volatile] = ACTIONS(SHIFT(14)),
         [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [229] = {
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(230)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(59)),
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(231)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [230] = {
-        [anon_sym_RPAREN] = ACTIONS(SHIFT(232)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [231] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(232)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(59)),
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(233)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [232] = {
+        [anon_sym_RPAREN] = ACTIONS(SHIFT(234)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [233] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
@@ -5016,7 +5109,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [232] = {
+    [234] = {
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
@@ -5025,29 +5118,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [233] = {
-        [anon_sym_RBRACK] = ACTIONS(SHIFT(231)),
+    [235] = {
+        [anon_sym_RBRACK] = ACTIONS(SHIFT(233)),
         [anon_sym_LPAREN] = ACTIONS(SHIFT(80)),
         [anon_sym_STAR] = ACTIONS(SHIFT(81)),
         [anon_sym_PLUS] = ACTIONS(SHIFT(82)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [234] = {
-        [anon_sym_SEMI] = ACTIONS(SHIFT(239)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [235] = {
-        [sym__init_declarator] = ACTIONS(SHIFT(237)),
-        [sym_declarator] = ACTIONS(SHIFT(219)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(220)),
-        [sym_pointer] = ACTIONS(SHIFT(40)),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(221)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(222)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
-        [sym_identifier] = ACTIONS(SHIFT(223)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [236] = {
+        [anon_sym_SEMI] = ACTIONS(SHIFT(241)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [237] = {
+        [sym__init_declarator] = ACTIONS(SHIFT(239)),
+        [sym_declarator] = ACTIONS(SHIFT(221)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(222)),
+        [sym_pointer] = ACTIONS(SHIFT(40)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(223)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(224)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
+        [sym_identifier] = ACTIONS(SHIFT(225)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [238] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declaration, 3)),
@@ -5082,17 +5175,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_number] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [237] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(238)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(235)),
+    [239] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(240)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(237)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(aux_sym_declaration_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [238] = {
+    [240] = {
         [anon_sym_SEMI] = ACTIONS(REDUCE(aux_sym_declaration_repeat1, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [239] = {
+    [241] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declaration, 4)),
@@ -5127,28 +5220,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_number] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [240] = {
-        [sym__init_declarator] = ACTIONS(SHIFT(241)),
-        [sym_declarator] = ACTIONS(SHIFT(219)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(220)),
-        [sym_pointer] = ACTIONS(SHIFT(40)),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(221)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(222)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
-        [sym_identifier] = ACTIONS(SHIFT(223)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [241] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(242)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(235)),
-        [anon_sym_SEMI] = ACTIONS(SHIFT(239)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [242] = {
-        [anon_sym_SEMI] = ACTIONS(SHIFT(243)),
+        [sym__init_declarator] = ACTIONS(SHIFT(243)),
+        [sym_declarator] = ACTIONS(SHIFT(221)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(222)),
+        [sym_pointer] = ACTIONS(SHIFT(40)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(223)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(224)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
+        [sym_identifier] = ACTIONS(SHIFT(225)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [243] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(244)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(237)),
+        [anon_sym_SEMI] = ACTIONS(SHIFT(241)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [244] = {
+        [anon_sym_SEMI] = ACTIONS(SHIFT(245)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [245] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declaration, 5)),
@@ -5183,7 +5276,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_number] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [244] = {
+    [246] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_function_definition, 4)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_function_definition, 4)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_function_definition, 4)),
@@ -5214,22 +5307,22 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_function_definition, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [245] = {
+    [247] = {
         [sym_compound_statement] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 2)),
         [anon_sym_LBRACE] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [246] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(247)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(235)),
-        [anon_sym_SEMI] = ACTIONS(SHIFT(248)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [247] = {
-        [anon_sym_SEMI] = ACTIONS(SHIFT(249)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [248] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(249)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(237)),
+        [anon_sym_SEMI] = ACTIONS(SHIFT(250)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [249] = {
+        [anon_sym_SEMI] = ACTIONS(SHIFT(251)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [250] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declaration, 3)),
@@ -5258,7 +5351,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [249] = {
+    [251] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declaration, 4)),
@@ -5287,28 +5380,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [250] = {
-        [sym__init_declarator] = ACTIONS(SHIFT(251)),
-        [sym_declarator] = ACTIONS(SHIFT(219)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(220)),
-        [sym_pointer] = ACTIONS(SHIFT(40)),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(221)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(222)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
-        [sym_identifier] = ACTIONS(SHIFT(223)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [251] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(252)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(235)),
-        [anon_sym_SEMI] = ACTIONS(SHIFT(249)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [252] = {
-        [anon_sym_SEMI] = ACTIONS(SHIFT(253)),
+        [sym__init_declarator] = ACTIONS(SHIFT(253)),
+        [sym_declarator] = ACTIONS(SHIFT(221)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(222)),
+        [sym_pointer] = ACTIONS(SHIFT(40)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(223)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(224)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
+        [sym_identifier] = ACTIONS(SHIFT(225)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [253] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(254)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(237)),
+        [anon_sym_SEMI] = ACTIONS(SHIFT(251)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [254] = {
+        [anon_sym_SEMI] = ACTIONS(SHIFT(255)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [255] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declaration, 5)),
@@ -5337,11 +5430,11 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [254] = {
-        [anon_sym_SEMI] = ACTIONS(SHIFT(256)),
+    [256] = {
+        [anon_sym_SEMI] = ACTIONS(SHIFT(258)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [255] = {
+    [257] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 3)),
@@ -5372,7 +5465,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [256] = {
+    [258] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 4)),
@@ -5403,7 +5496,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [257] = {
+    [259] = {
         [sym__type_specifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
         [sym_type_name] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
         [sym_struct_specifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
@@ -5416,33 +5509,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [258] = {
-        [sym__init_declarator] = ACTIONS(SHIFT(259)),
-        [sym_declarator] = ACTIONS(SHIFT(260)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(125)),
-        [sym_pointer] = ACTIONS(SHIFT(40)),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(126)),
-        [anon_sym_LPAREN] = ACTIONS(SHIFT(127)),
-        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
-        [sym_identifier] = ACTIONS(SHIFT(128)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [259] = {
-        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(263)),
-        [anon_sym_COMMA] = ACTIONS(SHIFT(235)),
-        [anon_sym_SEMI] = ACTIONS(SHIFT(256)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
     [260] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(139)),
+        [sym__init_declarator] = ACTIONS(SHIFT(261)),
+        [sym_declarator] = ACTIONS(SHIFT(262)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(127)),
+        [sym_pointer] = ACTIONS(SHIFT(40)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(128)),
+        [anon_sym_LPAREN] = ACTIONS(SHIFT(129)),
+        [anon_sym_STAR] = ACTIONS(SHIFT(43)),
+        [sym_identifier] = ACTIONS(SHIFT(130)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [261] = {
+        [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(265)),
+        [anon_sym_COMMA] = ACTIONS(SHIFT(237)),
+        [anon_sym_SEMI] = ACTIONS(SHIFT(258)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [262] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(141)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(140)),
+        [sym__type_specifier] = ACTIONS(SHIFT(142)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_declaration] = ACTIONS(SHIFT(141)),
+        [sym_declaration] = ACTIONS(SHIFT(143)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_compound_statement] = ACTIONS(SHIFT(244)),
-        [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(261)),
+        [sym_compound_statement] = ACTIONS(SHIFT(246)),
+        [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(263)),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(8)),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(9)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 1)),
@@ -5456,22 +5549,22 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [anon_sym_long] = ACTIONS(SHIFT(12)),
         [anon_sym_short] = ACTIONS(SHIFT(12)),
         [anon_sym_struct] = ACTIONS(SHIFT(13)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(144)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(146)),
         [anon_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
         [anon_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [anon_sym_EQ] = ACTIONS(SHIFT(145)),
+        [anon_sym_EQ] = ACTIONS(SHIFT(147)),
         [anon_sym_const] = ACTIONS(SHIFT(14)),
         [anon_sym_restrict] = ACTIONS(SHIFT(14)),
         [anon_sym_volatile] = ACTIONS(SHIFT(14)),
         [sym_identifier] = ACTIONS(SHIFT(15)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [261] = {
-        [sym_compound_statement] = ACTIONS(SHIFT(262)),
-        [anon_sym_LBRACE] = ACTIONS(SHIFT(144)),
+    [263] = {
+        [sym_compound_statement] = ACTIONS(SHIFT(264)),
+        [anon_sym_LBRACE] = ACTIONS(SHIFT(146)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [262] = {
+    [264] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_function_definition, 5)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_function_definition, 5)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_function_definition, 5)),
@@ -5502,11 +5595,11 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_function_definition, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [263] = {
-        [anon_sym_SEMI] = ACTIONS(SHIFT(264)),
+    [265] = {
+        [anon_sym_SEMI] = ACTIONS(SHIFT(266)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [264] = {
+    [266] = {
         [sym_preproc_define] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_function_definition] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 5)),
@@ -5537,7 +5630,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [265] = {
+    [267] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
diff --git a/spec/fixtures/parsers/javascript.c b/spec/fixtures/parsers/javascript.c
index c172dce0..216af2d8 100644
--- a/spec/fixtures/parsers/javascript.c
+++ b/spec/fixtures/parsers/javascript.c
@@ -594,7 +594,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '\n') ||
                 (lookahead == 'g')))
                 ADVANCE(29);
-            ACCEPT_TOKEN(sym_comment);
+            ACCEPT_TOKEN(sym_regex);
         case 28:
             if (!((lookahead == 0) ||
                 (lookahead == '\n')))
diff --git a/src/compiler/build_tables/build_lex_table.cc b/src/compiler/build_tables/build_lex_table.cc
index 49396137..53bcd3a8 100644
--- a/src/compiler/build_tables/build_lex_table.cc
+++ b/src/compiler/build_tables/build_lex_table.cc
@@ -6,8 +6,6 @@
 #include <utility>
 #include <vector>
 #include "compiler/build_tables/lex_conflict_manager.h"
-#include "compiler/build_tables/get_completion_status.h"
-#include "compiler/build_tables/get_metadata.h"
 #include "compiler/build_tables/lex_item.h"
 #include "compiler/build_tables/does_match_any_line.h"
 #include "compiler/parse_table.h"
@@ -51,7 +49,8 @@ class LexTableBuilder {
 
   LexTable build() {
     for (ParseState &parse_state : parse_table->states) {
-      LexItemSet item_set = build_lex_item_set(parse_state.expected_inputs(), false);
+      LexItemSet item_set =
+        build_lex_item_set(parse_state.expected_inputs(), false);
       parse_state.lex_state_id = add_lex_state(item_set);
     }
 
@@ -87,11 +86,11 @@ class LexTableBuilder {
         for (const rule_ptr &separator_rule : separator_rules)
           result.entries.insert(LexItem(
             symbol, rules::Seq::build({
-                      rules::Metadata::build(
-                        separator_rule,
-                        {
-                          { rules::START_TOKEN, 1 }, { rules::PRECEDENCE, -1 },
-                        }),
+                      rules::Metadata::build(separator_rule,
+                                             {
+                                               { rules::START_TOKEN, 1 },
+                                               { rules::PRECEDENCE, -99999 },
+                                             }),
                       rule,
                     })));
     }
@@ -120,25 +119,26 @@ class LexTableBuilder {
   void add_advance_actions(const LexItemSet &item_set, LexStateId state_id) {
     for (const auto &transition : item_set.transitions()) {
       const CharacterSet &rule = transition.first;
-      const LexItemSet &new_item_set = transition.second;
-      LexStateId new_state_id = add_lex_state(new_item_set);
-      auto action = LexAction::Advance(
-        new_state_id, precedence_range_for_item_set(new_item_set));
-      if (conflict_manager.resolve(action,
-                                   lex_table.state(state_id).default_action))
+      const LexItemSet &new_item_set = transition.second.first;
+      const PrecedenceRange &precedence = transition.second.second;
+      auto current_action = lex_table.state(state_id).default_action;
+      auto action = LexAction::Advance(-1, precedence);
+      if (conflict_manager.resolve(action, current_action)) {
+        action.state_index = add_lex_state(new_item_set);
         lex_table.state(state_id).actions[rule] = action;
+      }
     }
   }
 
   void add_accept_token_actions(const LexItemSet &item_set, LexStateId state_id) {
     for (const LexItem &item : item_set.entries) {
-      CompletionStatus completion_status = get_completion_status(item.rule);
+      LexItem::CompletionStatus completion_status = item.completion_status();
       if (completion_status.is_done) {
         auto current_action = lex_table.state(state_id).default_action;
-        auto new_action =
-          LexAction::Accept(item.lhs, completion_status.precedence);
-        if (conflict_manager.resolve(new_action, current_action))
-          lex_table.state(state_id).default_action = new_action;
+        auto action = LexAction::Accept(item.lhs, completion_status.precedence,
+                                        completion_status.is_string);
+        if (conflict_manager.resolve(action, current_action))
+          lex_table.state(state_id).default_action = action;
       }
     }
   }
@@ -148,16 +148,6 @@ class LexTableBuilder {
       if (item.is_token_start())
         lex_table.state(state_id).is_token_start = true;
   }
-
-  PrecedenceRange precedence_range_for_item_set(const LexItemSet &item_set) const {
-    PrecedenceRange result;
-    for (const auto &item : item_set.entries) {
-      auto precedence_range = get_metadata(item.rule, rules::PRECEDENCE);
-      result.add(precedence_range.min);
-      result.add(precedence_range.max);
-    }
-    return result;
-  }
 };
 
 LexTable build_lex_table(ParseTable *table, const LexicalGrammar &grammar) {
diff --git a/src/compiler/build_tables/build_parse_table.cc b/src/compiler/build_tables/build_parse_table.cc
index 2a5738a9..83a0ceed 100644
--- a/src/compiler/build_tables/build_parse_table.cc
+++ b/src/compiler/build_tables/build_parse_table.cc
@@ -8,8 +8,6 @@
 #include "compiler/parse_table.h"
 #include "compiler/build_tables/parse_conflict_manager.h"
 #include "compiler/build_tables/parse_item.h"
-#include "compiler/build_tables/get_completion_status.h"
-#include "compiler/build_tables/get_metadata.h"
 #include "compiler/build_tables/item_set_closure.h"
 #include "compiler/lexical_grammar.h"
 #include "compiler/syntax_grammar.h"
@@ -99,50 +97,28 @@ class ParseTableBuilder {
   void add_shift_actions(const ParseItemSet &item_set, ParseStateId state_id) {
     for (const auto &transition : item_set.transitions()) {
       const Symbol &symbol = transition.first;
-      const ParseItemSet &next_item_set = transition.second;
+      const ParseItemSet &next_item_set = transition.second.first;
+      const PrecedenceRange &precedence = transition.second.second;
 
       ParseAction *new_action = add_action(
-        state_id, symbol,
-        ParseAction::Shift(0, precedence_values_for_item_set(next_item_set)),
-        item_set);
+        state_id, symbol, ParseAction::Shift(0, precedence), item_set);
       if (new_action)
         new_action->state_index = add_parse_state(next_item_set);
     }
   }
 
-  struct CompletionStatus {
-    bool is_done;
-    int precedence;
-    rules::Associativity associativity;
-  };
-
-  CompletionStatus get_completion_status(const ParseItem &item) {
-    CompletionStatus result = { false, 0, rules::AssociativityNone };
-    if (item.step_index == item.production->size()) {
-      result.is_done = true;
-      if (item.step_index > 0) {
-        const ProductionStep &last_step =
-          item.production->at(item.step_index - 1);
-        result.precedence = last_step.precedence;
-        result.associativity = last_step.associativity;
-      }
-    }
-    return result;
-  }
-
   void add_reduce_actions(const ParseItemSet &item_set, ParseStateId state_id) {
     for (const auto &pair : item_set.entries) {
       const ParseItem &item = pair.first;
       const auto &lookahead_symbols = pair.second;
 
-      CompletionStatus completion_status = get_completion_status(item);
-      if (completion_status.is_done) {
+      ParseItem::CompletionStatus status = item.completion_status();
+      if (status.is_done) {
         ParseAction action =
           (item.lhs() == rules::START())
             ? ParseAction::Accept()
             : ParseAction::Reduce(Symbol(item.variable_index), item.step_index,
-                                  completion_status.precedence,
-                                  completion_status.associativity,
+                                  status.precedence, status.associativity,
                                   *item.production);
 
         for (const auto &lookahead_sym : *lookahead_symbols.entries)
@@ -319,16 +295,6 @@ class ParseTableBuilder {
     return result;
   }
 
-  PrecedenceRange precedence_values_for_item_set(const ParseItemSet &item_set) {
-    PrecedenceRange result;
-    for (const auto &pair : item_set.entries) {
-      const ParseItem &item = pair.first;
-      if (item.step_index > 0)
-        result.add(item.production->at(item.step_index - 1).precedence);
-    }
-    return result;
-  }
-
   string symbol_name(const rules::Symbol &symbol) const {
     if (symbol.is_built_in()) {
       if (symbol == rules::ERROR())
diff --git a/src/compiler/build_tables/get_completion_status.cc b/src/compiler/build_tables/get_completion_status.cc
deleted file mode 100644
index 4cc70c60..00000000
--- a/src/compiler/build_tables/get_completion_status.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "compiler/build_tables/get_completion_status.h"
-#include "compiler/rules/visitor.h"
-#include "compiler/rules/choice.h"
-#include "compiler/rules/seq.h"
-#include "compiler/rules/metadata.h"
-#include "compiler/rules/repeat.h"
-
-namespace tree_sitter {
-namespace build_tables {
-
-class GetCompletionStatus : public rules::RuleFn<CompletionStatus> {
- protected:
-  CompletionStatus apply_to(const rules::Choice *rule) {
-    for (const auto &element : rule->elements) {
-      CompletionStatus status = apply(element);
-      if (status.is_done)
-        return status;
-    }
-    return { false, 0, rules::AssociativityNone };
-  }
-
-  CompletionStatus apply_to(const rules::Metadata *rule) {
-    CompletionStatus result = apply(rule->rule);
-    if (result.is_done && !result.associativity) {
-      result.precedence = rule->value_for(rules::PRECEDENCE);
-      result.associativity =
-        (rules::Associativity)(rule->value_for(rules::ASSOCIATIVITY));
-    }
-    return result;
-  }
-
-  CompletionStatus apply_to(const rules::Repeat *rule) {
-    return apply(rule->content);
-  }
-
-  CompletionStatus apply_to(const rules::Blank *rule) {
-    return { true, 0, rules::AssociativityNone };
-  }
-
-  CompletionStatus apply_to(const rules::Seq *rule) {
-    CompletionStatus left_status = apply(rule->left);
-    if (left_status.is_done)
-      return apply(rule->right);
-    else
-      return { false, 0, rules::AssociativityNone };
-  }
-};
-
-CompletionStatus get_completion_status(const rule_ptr &rule) {
-  return GetCompletionStatus().apply(rule);
-}
-
-}  // namespace build_tables
-}  // namespace tree_sitter
diff --git a/src/compiler/build_tables/get_completion_status.h b/src/compiler/build_tables/get_completion_status.h
deleted file mode 100644
index 237f3eb2..00000000
--- a/src/compiler/build_tables/get_completion_status.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef COMPILER_BUILD_TABLES_GET_COMPLETION_STATUS_H_
-#define COMPILER_BUILD_TABLES_GET_COMPLETION_STATUS_H_
-
-#include "tree_sitter/compiler.h"
-#include "compiler/rules/metadata.h"
-
-namespace tree_sitter {
-namespace build_tables {
-
-struct CompletionStatus {
-  bool is_done;
-  int precedence;
-  rules::Associativity associativity;
-};
-
-CompletionStatus get_completion_status(const rule_ptr &);
-
-}  // namespace build_tables
-}  // namespace tree_sitter
-
-#endif  // COMPILER_BUILD_TABLES_GET_COMPLETION_STATUS_H_
diff --git a/src/compiler/build_tables/get_metadata.cc b/src/compiler/build_tables/get_metadata.cc
deleted file mode 100644
index 1adf4f89..00000000
--- a/src/compiler/build_tables/get_metadata.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "compiler/build_tables/get_metadata.h"
-#include <utility>
-#include "compiler/rules/visitor.h"
-#include "compiler/rules/seq.h"
-#include "compiler/rules/repeat.h"
-#include "compiler/rules/choice.h"
-#include "compiler/build_tables/rule_can_be_blank.h"
-
-namespace tree_sitter {
-namespace build_tables {
-
-using std::pair;
-
-MetadataRange get_metadata(const rule_ptr &rule, rules::MetadataKey key) {
-  class GetMetadata : public rules::RuleFn<pair<MetadataRange, bool>> {
-    rules::MetadataKey metadata_key;
-
-   public:
-    explicit GetMetadata(rules::MetadataKey key) : metadata_key(key) {}
-
-   protected:
-    pair<MetadataRange, bool> apply_to(const rules::Metadata *rule) {
-      pair<MetadataRange, bool> result = apply(rule->rule);
-      if (result.second) {
-        return result;
-      } else {
-        int value = rule->value_for(metadata_key);
-        return { { value, value }, value != 0 };
-      }
-    }
-
-    pair<MetadataRange, bool> apply_to(const rules::Choice *rule) {
-      pair<MetadataRange, bool> result(MetadataRange(0, 0), false);
-      for (const auto &element : rule->elements)
-        merge_result(&result, apply(element));
-      return result;
-    }
-
-    pair<MetadataRange, bool> apply_to(const rules::Seq *rule) {
-      pair<MetadataRange, bool> result = apply(rule->left);
-      if (rule_can_be_blank(rule->left))
-        merge_result(&result, apply(rule->right));
-      return result;
-    }
-
-    pair<MetadataRange, bool> apply_to(const rules::Repeat *rule) {
-      return apply(rule->content);
-    }
-
-   private:
-    void merge_result(pair<MetadataRange, bool> *left,
-                      const pair<MetadataRange, bool> &right) {
-      if (right.second) {
-        if (!left->second || right.first.min < left->first.min)
-          left->first.min = right.first.min;
-        if (!left->second || right.first.max > left->first.max)
-          left->first.max = right.first.max;
-        left->second = true;
-      }
-    }
-  };
-
-  return GetMetadata(key).apply(rule).first;
-}
-
-}  // namespace build_tables
-}  // namespace tree_sitter
diff --git a/src/compiler/build_tables/get_metadata.h b/src/compiler/build_tables/get_metadata.h
deleted file mode 100644
index a30a4915..00000000
--- a/src/compiler/build_tables/get_metadata.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef COMPILER_BUILD_TABLES_GET_METADATA_H_
-#define COMPILER_BUILD_TABLES_GET_METADATA_H_
-
-#include "compiler/rules/metadata.h"
-#include "tree_sitter/compiler.h"
-
-namespace tree_sitter {
-namespace build_tables {
-
-struct MetadataRange {
-  MetadataRange() : min(0), max(0) {}
-  MetadataRange(int min, int max) : min(min), max(max) {}
-
-  bool operator==(const MetadataRange &other) const {
-    return min == other.min && max == other.max;
-  }
-
-  int min;
-  int max;
-};
-
-MetadataRange get_metadata(const rule_ptr &, rules::MetadataKey);
-
-}  // namespace build_tables
-}  // namespace tree_sitter
-
-#endif  // COMPILER_BUILD_TABLES_GET_METADATA_H_
diff --git a/src/compiler/build_tables/lex_conflict_manager.cc b/src/compiler/build_tables/lex_conflict_manager.cc
index c272996b..e1702c79 100644
--- a/src/compiler/build_tables/lex_conflict_manager.cc
+++ b/src/compiler/build_tables/lex_conflict_manager.cc
@@ -28,12 +28,19 @@ bool LexConflictManager::resolve(const LexAction &new_action,
             return true;
           else if (new_precedence < old_precedence)
             return false;
+          else if (new_action.is_string && !old_action.is_string)
+            return true;
+          else if (old_action.is_string && !new_action.is_string)
+            return false;
           else
             return new_action.symbol.index < old_action.symbol.index;
         }
 
         case LexActionTypeAdvance:
-          return true;
+          if (old_precedence > new_action.precedence_range.max)
+            return false;
+          else
+            return true;
 
         default:
           return false;
diff --git a/src/compiler/build_tables/lex_item.cc b/src/compiler/build_tables/lex_item.cc
index ddb41996..43c8fe72 100644
--- a/src/compiler/build_tables/lex_item.cc
+++ b/src/compiler/build_tables/lex_item.cc
@@ -1,8 +1,13 @@
 #include "compiler/build_tables/lex_item.h"
 #include <unordered_set>
-#include "compiler/build_tables/get_metadata.h"
 #include "compiler/build_tables/lex_item_transitions.h"
+#include "compiler/build_tables/rule_can_be_blank.h"
+#include "compiler/rules/choice.h"
+#include "compiler/rules/metadata.h"
+#include "compiler/rules/seq.h"
 #include "compiler/rules/symbol.h"
+#include "compiler/rules/repeat.h"
+#include "compiler/rules/visitor.h"
 
 namespace tree_sitter {
 namespace build_tables {
@@ -22,7 +27,68 @@ bool LexItem::operator==(const LexItem &other) const {
 }
 
 bool LexItem::is_token_start() const {
-  return get_metadata(rule, rules::START_TOKEN).max > 0;
+  class IsTokenStart : public rules::RuleFn<bool> {
+    bool apply_to(const rules::Seq *rule) {
+      return apply(rule->left) ||
+             (rule_can_be_blank(rule->left) && apply(rule->right));
+    }
+
+    bool apply_to(const rules::Metadata *rule) {
+      return (rule->value_for(rules::START_TOKEN) > 0) || apply(rule->rule);
+    }
+
+    bool apply_to(const rules::Choice *rule) {
+      for (const rule_ptr &element : rule->elements)
+        if (apply(element))
+          return true;
+      return false;
+    }
+  };
+
+  return IsTokenStart().apply(rule);
+}
+
+LexItem::CompletionStatus LexItem::completion_status() const {
+  class GetCompletionStatus : public rules::RuleFn<CompletionStatus> {
+   protected:
+    CompletionStatus apply_to(const rules::Choice *rule) {
+      for (const auto &element : rule->elements) {
+        CompletionStatus status = apply(element);
+        if (status.is_done)
+          return status;
+      }
+      return { false, 0, false };
+    }
+
+    CompletionStatus apply_to(const rules::Metadata *rule) {
+      CompletionStatus result = apply(rule->rule);
+      if (result.is_done) {
+        if (!result.precedence && rule->value_for(rules::PRECEDENCE))
+          result.precedence = rule->value_for(rules::PRECEDENCE);
+        if (rule->value_for(rules::IS_STRING))
+          result.is_string = true;
+      }
+      return result;
+    }
+
+    CompletionStatus apply_to(const rules::Repeat *rule) {
+      return apply(rule->content);
+    }
+
+    CompletionStatus apply_to(const rules::Blank *rule) {
+      return { true, 0, false };
+    }
+
+    CompletionStatus apply_to(const rules::Seq *rule) {
+      CompletionStatus left_status = apply(rule->left);
+      if (left_status.is_done)
+        return apply(rule->right);
+      else
+        return { false, 0, false };
+    }
+  };
+
+  return GetCompletionStatus().apply(rule);
 }
 
 size_t LexItem::Hash::operator()(const LexItem &item) const {
@@ -45,8 +111,8 @@ bool LexItemSet::operator==(const LexItemSet &other) const {
   return entries == other.entries;
 }
 
-map<CharacterSet, LexItemSet> LexItemSet::transitions() const {
-  map<CharacterSet, LexItemSet> result;
+LexItemSet::TransitionMap LexItemSet::transitions() const {
+  TransitionMap result;
   for (const LexItem &item : entries)
     lex_item_transitions(&result, item);
   return result;
diff --git a/src/compiler/build_tables/lex_item.h b/src/compiler/build_tables/lex_item.h
index 0ff4d0e7..b547df4d 100644
--- a/src/compiler/build_tables/lex_item.h
+++ b/src/compiler/build_tables/lex_item.h
@@ -3,25 +3,35 @@
 
 #include <unordered_set>
 #include <map>
+#include <utility>
 #include <string>
 #include "compiler/rules/character_set.h"
 #include "compiler/rules/symbol.h"
+#include "compiler/precedence_range.h"
 
 namespace tree_sitter {
 namespace build_tables {
 
 class LexItem {
  public:
-  LexItem(const rules::Symbol &lhs, rule_ptr rule);
-  bool operator==(const LexItem &other) const;
-  bool is_token_start() const;
+  LexItem(const rules::Symbol &, rule_ptr);
 
-  rules::Symbol lhs;
-  rule_ptr rule;
+  struct CompletionStatus {
+    bool is_done;
+    int precedence;
+    bool is_string;
+  };
 
   struct Hash {
     size_t operator()(const LexItem &) const;
   };
+
+  bool operator==(const LexItem &other) const;
+  bool is_token_start() const;
+  CompletionStatus completion_status() const;
+
+  rules::Symbol lhs;
+  rule_ptr rule;
 };
 
 class LexItemSet {
@@ -29,14 +39,17 @@ class LexItemSet {
   LexItemSet();
   explicit LexItemSet(const std::unordered_set<LexItem, LexItem::Hash> &);
 
-  bool operator==(const LexItemSet &) const;
-  std::map<rules::CharacterSet, LexItemSet> transitions() const;
-
-  std::unordered_set<LexItem, LexItem::Hash> entries;
+  typedef std::map<rules::CharacterSet, std::pair<LexItemSet, PrecedenceRange>>
+    TransitionMap;
 
   struct Hash {
     size_t operator()(const LexItemSet &) const;
   };
+
+  bool operator==(const LexItemSet &) const;
+  TransitionMap transitions() const;
+
+  std::unordered_set<LexItem, LexItem::Hash> entries;
 };
 
 }  // namespace build_tables
diff --git a/src/compiler/build_tables/lex_item_transitions.cc b/src/compiler/build_tables/lex_item_transitions.cc
index 099205c7..e3312af3 100644
--- a/src/compiler/build_tables/lex_item_transitions.cc
+++ b/src/compiler/build_tables/lex_item_transitions.cc
@@ -25,8 +25,9 @@ using std::vector;
 using rules::CharacterSet;
 
 class LexItemTransitions : public rules::RuleFn<void> {
-  map<CharacterSet, LexItemSet> *transitions;
+  LexItemSet::TransitionMap *transitions;
   const rules::Symbol &item_lhs;
+  vector<int> *precedence_stack;
 
   LexItemSet transform_item_set(const LexItemSet &item_set,
                                 function<rule_ptr(rule_ptr)> callback) {
@@ -36,23 +37,29 @@ class LexItemTransitions : public rules::RuleFn<void> {
     return new_set;
   }
 
-  void merge_transition(map<CharacterSet, LexItemSet> *transitions,
-                        CharacterSet new_char_set, LexItemSet new_item_set) {
-    vector<pair<CharacterSet, LexItemSet>> new_entries;
+  void merge_transition(LexItemSet::TransitionMap *transitions,
+                        CharacterSet new_char_set, LexItemSet new_item_set,
+                        PrecedenceRange new_precedence_range) {
+    vector<pair<CharacterSet, pair<LexItemSet, PrecedenceRange>>> new_entries;
 
     auto iter = transitions->begin();
     while (iter != transitions->end()) {
       CharacterSet existing_char_set = iter->first;
-      LexItemSet &existing_item_set = iter->second;
+      LexItemSet &existing_item_set = iter->second.first;
+      PrecedenceRange &existing_precedence_range = iter->second.second;
 
       CharacterSet intersection = existing_char_set.remove_set(new_char_set);
       if (!intersection.is_empty()) {
         new_char_set.remove_set(intersection);
         if (!existing_char_set.is_empty())
-          new_entries.push_back({ existing_char_set, existing_item_set });
+          new_entries.push_back(
+            { existing_char_set,
+              { existing_item_set, existing_precedence_range } });
         existing_item_set.entries.insert(new_item_set.entries.begin(),
                                          new_item_set.entries.end());
-        new_entries.push_back({ intersection, existing_item_set });
+        existing_precedence_range.add(new_precedence_range);
+        new_entries.push_back(
+          { intersection, { existing_item_set, existing_precedence_range } });
         transitions->erase(iter++);
       } else {
         iter++;
@@ -62,14 +69,22 @@ class LexItemTransitions : public rules::RuleFn<void> {
     transitions->insert(new_entries.begin(), new_entries.end());
 
     if (!new_char_set.is_empty())
-      transitions->insert({ new_char_set, new_item_set });
+      transitions->insert(
+        { new_char_set, { new_item_set, new_precedence_range } });
+  }
+
+  PrecedenceRange merge_precedence(PrecedenceRange precedence) {
+    if (precedence.empty && !precedence_stack->empty())
+      precedence.add(precedence_stack->back());
+    return precedence;
   }
 
   void apply_to(const CharacterSet *rule) {
     merge_transition(transitions, *rule,
                      LexItemSet({
                        LexItem(item_lhs, rules::Blank::build()),
-                     }));
+                     }),
+                     PrecedenceRange());
   }
 
   void apply_to(const rules::Choice *rule) {
@@ -78,52 +93,68 @@ class LexItemTransitions : public rules::RuleFn<void> {
   }
 
   void apply_to(const rules::Seq *rule) {
-    map<CharacterSet, LexItemSet> left_transitions;
-    LexItemTransitions(&left_transitions, item_lhs).apply(rule->left);
-    for (const auto &pair : left_transitions)
+    LexItemSet::TransitionMap left_transitions;
+    LexItemTransitions(&left_transitions, this).apply(rule->left);
+    for (const auto &pair : left_transitions) {
       merge_transition(
         transitions, pair.first,
-        transform_item_set(pair.second, [&rule](rule_ptr item_rule) {
+        transform_item_set(pair.second.first, [&rule](rule_ptr item_rule) {
           return rules::Seq::build({ item_rule, rule->right });
-        }));
+        }), merge_precedence(pair.second.second));
+    }
 
     if (rule_can_be_blank(rule->left))
       apply(rule->right);
   }
 
   void apply_to(const rules::Repeat *rule) {
-    map<CharacterSet, LexItemSet> content_transitions;
-    LexItemTransitions(&content_transitions, item_lhs).apply(rule->content);
+    LexItemSet::TransitionMap content_transitions;
+    LexItemTransitions(&content_transitions, this).apply(rule->content);
     for (const auto &pair : content_transitions) {
-      merge_transition(transitions, pair.first, pair.second);
+      merge_transition(transitions, pair.first, pair.second.first,
+                       merge_precedence(pair.second.second));
       merge_transition(
         transitions, pair.first,
-        transform_item_set(pair.second, [&rule](rule_ptr item_rule) {
+        transform_item_set(pair.second.first, [&rule](rule_ptr item_rule) {
           return rules::Seq::build({ item_rule, rule->copy() });
-        }));
+        }), merge_precedence(pair.second.second));
     }
   }
 
   void apply_to(const rules::Metadata *rule) {
-    map<CharacterSet, LexItemSet> content_transitions;
-    LexItemTransitions(&content_transitions, item_lhs).apply(rule->rule);
+    LexItemSet::TransitionMap content_transitions;
+    precedence_stack->push_back(rule->value_for(rules::PRECEDENCE));
+
+    LexItemTransitions(&content_transitions, this).apply(rule->rule);
     for (const auto &pair : content_transitions)
       merge_transition(
         transitions, pair.first,
-        transform_item_set(pair.second, [&rule](rule_ptr item_rule) {
+        transform_item_set(pair.second.first, [&rule](rule_ptr item_rule) {
           return rules::Metadata::build(item_rule, rule->value);
-        }));
+        }), pair.second.second);
+
+    precedence_stack->pop_back();
   }
 
  public:
-  LexItemTransitions(map<CharacterSet, LexItemSet> *transitions,
-                     const rules::Symbol &item_lhs)
-      : transitions(transitions), item_lhs(item_lhs) {}
+  LexItemTransitions(LexItemSet::TransitionMap *transitions,
+                     const rules::Symbol &item_lhs,
+                     vector<int> *precedence_stack)
+      : transitions(transitions),
+        item_lhs(item_lhs),
+        precedence_stack(precedence_stack) {}
+
+  LexItemTransitions(LexItemSet::TransitionMap *transitions,
+                     LexItemTransitions *other)
+      : transitions(transitions),
+        item_lhs(other->item_lhs),
+        precedence_stack(other->precedence_stack) {}
 };
 
-void lex_item_transitions(map<CharacterSet, LexItemSet> *transitions,
+void lex_item_transitions(LexItemSet::TransitionMap *transitions,
                           const LexItem &item) {
-  LexItemTransitions(transitions, item.lhs).apply(item.rule);
+  vector<int> precedence_stack;
+  LexItemTransitions(transitions, item.lhs, &precedence_stack).apply(item.rule);
 }
 
 }  // namespace build_tables
diff --git a/src/compiler/build_tables/lex_item_transitions.h b/src/compiler/build_tables/lex_item_transitions.h
index 342df991..b9dc25d0 100644
--- a/src/compiler/build_tables/lex_item_transitions.h
+++ b/src/compiler/build_tables/lex_item_transitions.h
@@ -1,8 +1,6 @@
 #ifndef COMPILER_BUILD_TABLES_LEX_ITEM_TRANSITIONS_H_
 #define COMPILER_BUILD_TABLES_LEX_ITEM_TRANSITIONS_H_
 
-#include <map>
-#include <set>
 #include "compiler/rules/character_set.h"
 #include "compiler/rules/symbol.h"
 #include "compiler/build_tables/lex_item.h"
@@ -10,7 +8,7 @@
 namespace tree_sitter {
 namespace build_tables {
 
-void lex_item_transitions(std::map<rules::CharacterSet, LexItemSet> *transitions,
+void lex_item_transitions(LexItemSet::TransitionMap *transitions,
                           const LexItem &);
 
 }  // namespace build_tables
diff --git a/src/compiler/build_tables/parse_item.cc b/src/compiler/build_tables/parse_item.cc
index 1209d808..89d42cf1 100644
--- a/src/compiler/build_tables/parse_item.cc
+++ b/src/compiler/build_tables/parse_item.cc
@@ -41,14 +41,23 @@ Symbol ParseItem::lhs() const {
   return Symbol(variable_index);
 }
 
-bool ParseItem::is_done() const {
-  return step_index == production->size();
+ParseItem::CompletionStatus ParseItem::completion_status() const {
+  CompletionStatus result = { false, 0, rules::AssociativityNone };
+  if (step_index == production->size()) {
+    result.is_done = true;
+    if (step_index > 0) {
+      const ProductionStep &last_step = production->at(step_index - 1);
+      result.precedence = last_step.precedence;
+      result.associativity = last_step.associativity;
+    }
+  }
+  return result;
 }
 
 int ParseItem::precedence() const {
   if (production->empty())
     return 0;
-  else if (is_done())
+  else if (completion_status().is_done)
     return production->back().precedence;
   else
     return production->at(step_index).precedence;
@@ -57,7 +66,7 @@ int ParseItem::precedence() const {
 rules::Associativity ParseItem::associativity() const {
   if (production->empty())
     return rules::AssociativityNone;
-  else if (is_done())
+  else if (completion_status().is_done)
     return production->back().associativity;
   else
     return production->at(step_index).associativity;
@@ -66,7 +75,7 @@ rules::Associativity ParseItem::associativity() const {
 pair<int, int> ParseItem::remaining_rule_id() const {
   if (production->empty())
     return { -2, -1 };
-  else if (is_done())
+  else if (completion_status().is_done)
     return { production->back().associativity, production->back().precedence };
   else
     return { -1, production->at(step_index).rule_id };
@@ -104,8 +113,8 @@ size_t ParseItemSet::Hash::operator()(const ParseItemSet &item_set) const {
   return result;
 }
 
-map<Symbol, ParseItemSet> ParseItemSet::transitions() const {
-  map<Symbol, ParseItemSet> result;
+ParseItemSet::TransitionMap ParseItemSet::transitions() const {
+  ParseItemSet::TransitionMap result;
   for (const auto &pair : entries) {
     const ParseItem &item = pair.first;
     const LookaheadSet &lookahead_symbols = pair.second;
@@ -114,9 +123,11 @@ map<Symbol, ParseItemSet> ParseItemSet::transitions() const {
 
     size_t step = item.step_index + 1;
     Symbol symbol = item.production->at(item.step_index).symbol;
+    int precedence = item.production->at(item.step_index).precedence;
     ParseItem new_item(item.lhs(), *item.production, step);
 
-    result[symbol].entries[new_item] = lookahead_symbols;
+    result[symbol].first.entries[new_item] = lookahead_symbols;
+    result[symbol].second.add(precedence);
   }
 
   return result;
diff --git a/src/compiler/build_tables/parse_item.h b/src/compiler/build_tables/parse_item.h
index ba4d747b..3471f7ce 100644
--- a/src/compiler/build_tables/parse_item.h
+++ b/src/compiler/build_tables/parse_item.h
@@ -7,6 +7,7 @@
 #include "compiler/rules/symbol.h"
 #include "compiler/rules/metadata.h"
 #include "compiler/syntax_grammar.h"
+#include "compiler/precedence_range.h"
 
 namespace tree_sitter {
 namespace build_tables {
@@ -15,21 +16,27 @@ class ParseItem {
  public:
   ParseItem(const rules::Symbol &, const Production &, unsigned int);
 
-  bool operator==(const ParseItem &other) const;
-  bool operator<(const ParseItem &other) const;
-  rules::Symbol lhs() const;
-  std::pair<int, int> remaining_rule_id() const;
-  bool is_done() const;
-  int precedence() const;
-  rules::Associativity associativity() const;
-
-  int variable_index;
-  const Production *production;
-  unsigned int step_index;
+  struct CompletionStatus {
+    bool is_done;
+    int precedence;
+    rules::Associativity associativity;
+  };
 
   struct Hash {
     size_t operator()(const ParseItem &) const;
   };
+
+  bool operator==(const ParseItem &other) const;
+  bool operator<(const ParseItem &other) const;
+  rules::Symbol lhs() const;
+  std::pair<int, int> remaining_rule_id() const;
+  int precedence() const;
+  rules::Associativity associativity() const;
+  CompletionStatus completion_status() const;
+
+  int variable_index;
+  const Production *production;
+  unsigned int step_index;
 };
 
 class ParseItemSet {
@@ -37,14 +44,17 @@ class ParseItemSet {
   ParseItemSet();
   explicit ParseItemSet(const std::map<ParseItem, LookaheadSet> &);
 
-  std::map<rules::Symbol, ParseItemSet> transitions() const;
-  bool operator==(const ParseItemSet &) const;
-
-  std::map<ParseItem, LookaheadSet> entries;
+  typedef std::map<rules::Symbol, std::pair<ParseItemSet, PrecedenceRange>>
+    TransitionMap;
 
   struct Hash {
     size_t operator()(const ParseItemSet &) const;
   };
+
+  TransitionMap transitions() const;
+  bool operator==(const ParseItemSet &) const;
+
+  std::map<ParseItem, LookaheadSet> entries;
 };
 
 }  // namespace build_tables
diff --git a/src/compiler/lex_table.cc b/src/compiler/lex_table.cc
index 255c24f4..e74233fc 100644
--- a/src/compiler/lex_table.cc
+++ b/src/compiler/lex_table.cc
@@ -17,24 +17,26 @@ LexAction::LexAction()
       precedence_range({ 0, 0 }) {}
 
 LexAction::LexAction(LexActionType type, size_t state_index, Symbol symbol,
-                     PrecedenceRange precedence_range)
+                     PrecedenceRange precedence_range, bool is_string)
     : type(type),
       symbol(symbol),
       state_index(state_index),
-      precedence_range(precedence_range) {}
+      precedence_range(precedence_range),
+      is_string(is_string) {}
 
 LexAction LexAction::Error() {
-  return LexAction(LexActionTypeError, -1, Symbol(-1), { 0, 0 });
+  return LexAction(LexActionTypeError, -1, Symbol(-1), { 0, 0 }, false);
 }
 
 LexAction LexAction::Advance(size_t state_index,
                              PrecedenceRange precedence_range) {
   return LexAction(LexActionTypeAdvance, state_index, Symbol(-1),
-                   precedence_range);
+                   precedence_range, false);
 }
 
-LexAction LexAction::Accept(Symbol symbol, int precedence) {
-  return LexAction(LexActionTypeAccept, -1, symbol, { precedence, precedence });
+LexAction LexAction::Accept(Symbol symbol, int precedence, bool is_string) {
+  return LexAction(LexActionTypeAccept, -1, symbol, { precedence, precedence },
+                   is_string);
 }
 
 bool LexAction::operator==(const LexAction &other) const {
diff --git a/src/compiler/lex_table.h b/src/compiler/lex_table.h
index ab6c4a3f..b6288a07 100644
--- a/src/compiler/lex_table.h
+++ b/src/compiler/lex_table.h
@@ -19,11 +19,11 @@ typedef enum {
 
 class LexAction {
   LexAction(LexActionType type, size_t state_index, rules::Symbol symbol,
-            PrecedenceRange precedence_range);
+            PrecedenceRange precedence_range, bool is_string);
 
  public:
   LexAction();
-  static LexAction Accept(rules::Symbol symbol, int precedence);
+  static LexAction Accept(rules::Symbol symbol, int precedence, bool is_string);
   static LexAction Error();
   static LexAction Advance(size_t state_index, PrecedenceRange precedence_range);
   bool operator==(const LexAction &action) const;
@@ -32,6 +32,7 @@ class LexAction {
   rules::Symbol symbol;
   size_t state_index;
   PrecedenceRange precedence_range;
+  bool is_string;
 };
 
 }  // namespace tree_sitter
diff --git a/src/compiler/precedence_range.cc b/src/compiler/precedence_range.cc
index c5a228bc..2f6b7ecf 100644
--- a/src/compiler/precedence_range.cc
+++ b/src/compiler/precedence_range.cc
@@ -7,6 +7,9 @@ PrecedenceRange::PrecedenceRange() : min(0), max(0), empty(true) {}
 PrecedenceRange::PrecedenceRange(int min, int max)
     : min(min), max(max), empty(false) {}
 
+PrecedenceRange::PrecedenceRange(int value)
+    : min(value), max(value), empty(false) {}
+
 void PrecedenceRange::add(int new_value) {
   if (empty) {
     min = new_value;
@@ -20,6 +23,13 @@ void PrecedenceRange::add(int new_value) {
   }
 }
 
+void PrecedenceRange::add(const PrecedenceRange &other) {
+  if (!other.empty) {
+    add(other.min);
+    add(other.max);
+  }
+}
+
 bool PrecedenceRange::operator<(const PrecedenceRange &other) const {
   if (empty)
     return !other.empty;
diff --git a/src/compiler/precedence_range.h b/src/compiler/precedence_range.h
index 5e7903c2..f2f52de4 100644
--- a/src/compiler/precedence_range.h
+++ b/src/compiler/precedence_range.h
@@ -5,9 +5,11 @@ namespace tree_sitter {
 
 struct PrecedenceRange {
   PrecedenceRange();
+  explicit PrecedenceRange(int value);
   PrecedenceRange(int min, int max);
 
   void add(int value);
+  void add(const PrecedenceRange &);
   bool operator==(const PrecedenceRange &other) const;
   bool operator<(const PrecedenceRange &other) const;
 
diff --git a/src/compiler/prepare_grammar/expand_tokens.cc b/src/compiler/prepare_grammar/expand_tokens.cc
index 05e32e46..21023990 100644
--- a/src/compiler/prepare_grammar/expand_tokens.cc
+++ b/src/compiler/prepare_grammar/expand_tokens.cc
@@ -47,7 +47,7 @@ class ExpandTokens : public rules::IdentityRuleFn {
     return make_shared<rules::Metadata>(
       rules::Seq::build(elements),
       std::map<rules::MetadataKey, int>({
-        { rules::IS_TOKEN, 1 }, { rules::PRECEDENCE, 1 },
+        { rules::IS_TOKEN, 1 }, { rules::IS_STRING, 1 },
       }));
   }
 
diff --git a/src/compiler/rules/metadata.h b/src/compiler/rules/metadata.h
index ea4f9ba5..bcf23bd8 100644
--- a/src/compiler/rules/metadata.h
+++ b/src/compiler/rules/metadata.h
@@ -18,8 +18,9 @@ enum Associativity {
 enum MetadataKey {
   START_TOKEN,
   PRECEDENCE,
-  IS_TOKEN,
   ASSOCIATIVITY,
+  IS_TOKEN,
+  IS_STRING,
 };
 
 class Metadata : public Rule {