diff --git a/examples/parsers/arithmetic.c b/examples/parsers/arithmetic.c
index fd574ef8..f2714ae8 100644
--- a/examples/parsers/arithmetic.c
+++ b/examples/parsers/arithmetic.c
@@ -8,7 +8,6 @@ enum {
     ts_sym_term,
     ts_sym_times,
     ts_sym_variable,
-    ts_aux_sym_end,
     ts_aux_sym_token1,
     ts_aux_sym_token2,
 };
@@ -21,7 +20,6 @@ SYMBOL_NAMES {
     "term",
     "times",
     "variable",
-    "end",
     "token1",
     "token2",
 };
@@ -37,93 +35,81 @@ LEX_FN() {
     START_LEXER();
     switch (LEX_STATE()) {
         case 0:
-            if (LOOKAHEAD_CHAR() == '\0')
-                ADVANCE(1);
             LEX_ERROR();
         case 1:
-            ACCEPT_TOKEN(ts_aux_sym_end);
-        case 2:
-            if (LOOKAHEAD_CHAR() == '\0')
-                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(3);
+                ADVANCE(2);
             LEX_ERROR();
-        case 3:
+        case 2:
             ACCEPT_TOKEN(ts_sym_plus);
-        case 4:
+        case 3:
             if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(5);
+                ADVANCE(4);
             LEX_ERROR();
-        case 5:
+        case 4:
             ACCEPT_TOKEN(ts_aux_sym_token2);
+        case 5:
+            if (LOOKAHEAD_CHAR() == ')')
+                ADVANCE(4);
+            if (LOOKAHEAD_CHAR() == '+')
+                ADVANCE(2);
+            LEX_ERROR();
         case 6:
             if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(5);
+                ADVANCE(4);
+            if (LOOKAHEAD_CHAR() == '*')
+                ADVANCE(7);
             if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(3);
+                ADVANCE(2);
             LEX_ERROR();
         case 7:
-            if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(5);
-            if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(8);
-            if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(3);
-            LEX_ERROR();
-        case 8:
             ACCEPT_TOKEN(ts_sym_times);
-        case 9:
+        case 8:
             if (LOOKAHEAD_CHAR() == '(')
+                ADVANCE(9);
+            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
                 ADVANCE(10);
-            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(11);
             if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
                 ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
-                ADVANCE(12);
+                ADVANCE(11);
             LEX_ERROR();
-        case 10:
+        case 9:
             ACCEPT_TOKEN(ts_aux_sym_token1);
-        case 11:
+        case 10:
             if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(11);
+                ADVANCE(10);
             ACCEPT_TOKEN(ts_sym_number);
-        case 12:
+        case 11:
             if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
                 ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
-                ADVANCE(12);
+                ADVANCE(11);
             ACCEPT_TOKEN(ts_sym_variable);
-        case 13:
+        case 12:
             if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(5);
+                ADVANCE(4);
             if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(8);
+                ADVANCE(7);
+            LEX_ERROR();
+        case 13:
+            if (LOOKAHEAD_CHAR() == '*')
+                ADVANCE(7);
+            if (LOOKAHEAD_CHAR() == '+')
+                ADVANCE(2);
             LEX_ERROR();
         case 14:
-            if (LOOKAHEAD_CHAR() == '\0')
-                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(8);
-            if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(3);
-            LEX_ERROR();
-        case 15:
-            if (LOOKAHEAD_CHAR() == '\0')
-                ADVANCE(1);
-            if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(8);
+                ADVANCE(7);
             LEX_ERROR();
         case ts_lex_state_error:
-            if (LOOKAHEAD_CHAR() == '\0')
-                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(8);
+                ADVANCE(7);
             if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(3);
+                ADVANCE(2);
             if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(11);
+                ADVANCE(10);
             if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
                 ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
-                ADVANCE(12);
+                ADVANCE(11);
             LEX_ERROR();
         default:
             LEX_PANIC();
@@ -135,7 +121,7 @@ PARSE_FN() {
     START_PARSER();
     switch (PARSE_STATE()) {
         case 0:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(1);
@@ -155,25 +141,25 @@ PARSE_FN() {
         case 1:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     ACCEPT_INPUT();
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 2:
-            SET_LEX_STATE(14);
+            SET_LEX_STATE(13);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 1, COLLAPSE({0}));
                 case ts_sym_times:
                     SHIFT(3);
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_term, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_end}));
+                    PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_builtin_sym_end}));
             }
         case 3:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(4);
@@ -187,27 +173,27 @@ PARSE_FN() {
                     PARSE_ERROR(4, EXPECT({ts_sym_factor, ts_sym_number, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 4:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
                 default:
-                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
+                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_builtin_sym_end}));
             }
         case 5:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
+                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_builtin_sym_end}));
             }
         case 6:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(7);
@@ -225,7 +211,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 7:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(8);
@@ -233,17 +219,17 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 8:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
                 default:
-                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
+                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_builtin_sym_end}));
             }
         case 9:
-            SET_LEX_STATE(7);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 1, COLLAPSE({0}));
@@ -255,7 +241,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_token2}));
             }
         case 10:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(11);
@@ -269,7 +255,7 @@ PARSE_FN() {
                     PARSE_ERROR(4, EXPECT({ts_sym_factor, ts_sym_number, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 11:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
@@ -279,7 +265,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 12:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -289,7 +275,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 13:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(14);
@@ -307,7 +293,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 14:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(15);
@@ -315,7 +301,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 15:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -325,7 +311,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 16:
-            SET_LEX_STATE(7);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -337,7 +323,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_token2}));
             }
         case 17:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     SHIFT(18);
@@ -347,7 +333,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 18:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(19);
@@ -363,7 +349,7 @@ PARSE_FN() {
                     PARSE_ERROR(5, EXPECT({ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 19:
-            SET_LEX_STATE(13);
+            SET_LEX_STATE(12);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     SHIFT(20);
@@ -373,7 +359,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_token2}));
             }
         case 20:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(21);
@@ -387,7 +373,7 @@ PARSE_FN() {
                     PARSE_ERROR(4, EXPECT({ts_sym_factor, ts_sym_number, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 21:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
@@ -395,7 +381,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 22:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -403,7 +389,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 23:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(24);
@@ -421,7 +407,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 24:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(25);
@@ -429,7 +415,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 25:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -437,7 +423,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 26:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(27);
@@ -455,7 +441,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 27:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(28);
@@ -463,7 +449,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 28:
-            SET_LEX_STATE(7);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -475,7 +461,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_token2}));
             }
         case 29:
-            SET_LEX_STATE(13);
+            SET_LEX_STATE(12);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -485,7 +471,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_token2}));
             }
         case 30:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_expression, 3, COLLAPSE({0, 0, 0}));
@@ -493,7 +479,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 31:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(32);
@@ -511,7 +497,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 32:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(33);
@@ -519,7 +505,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 33:
-            SET_LEX_STATE(13);
+            SET_LEX_STATE(12);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -529,29 +515,29 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_token2}));
             }
         case 34:
-            SET_LEX_STATE(14);
+            SET_LEX_STATE(13);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_end}));
+                    PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_builtin_sym_end}));
             }
         case 35:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     SHIFT(36);
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_expression, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
+                    PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_builtin_sym_end}));
             }
         case 36:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(37);
@@ -567,17 +553,17 @@ PARSE_FN() {
                     PARSE_ERROR(5, EXPECT({ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 37:
-            SET_LEX_STATE(15);
+            SET_LEX_STATE(14);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     SHIFT(38);
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_term, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_end}));
+                    PARSE_ERROR(2, EXPECT({ts_sym_times, ts_builtin_sym_end}));
             }
         case 38:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(39);
@@ -593,21 +579,21 @@ PARSE_FN() {
         case 39:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 40:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 41:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(42);
@@ -625,7 +611,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 42:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(43);
@@ -635,31 +621,31 @@ PARSE_FN() {
         case 43:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 44:
-            SET_LEX_STATE(15);
+            SET_LEX_STATE(14);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_end}));
+                    PARSE_ERROR(2, EXPECT({ts_sym_times, ts_builtin_sym_end}));
             }
         case 45:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_expression, 3, COLLAPSE({0, 0, 0}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 46:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(47);
@@ -677,7 +663,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 47:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(48);
@@ -685,17 +671,17 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 48:
-            SET_LEX_STATE(15);
+            SET_LEX_STATE(14);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
                 default:
-                    PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_end}));
+                    PARSE_ERROR(2, EXPECT({ts_sym_times, ts_builtin_sym_end}));
             }
         case 49:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(50);
@@ -713,7 +699,7 @@ PARSE_FN() {
                     PARSE_ERROR(6, EXPECT({ts_sym_expression, ts_sym_factor, ts_sym_number, ts_sym_term, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 50:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(3);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(51);
@@ -721,16 +707,16 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 51:
-            SET_LEX_STATE(14);
+            SET_LEX_STATE(13);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
                 default:
-                    PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_end}));
+                    PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_builtin_sym_end}));
             }
         default:
             PARSE_PANIC();
diff --git a/examples/parsers/json.c b/examples/parsers/json.c
index b5c66399..468ba8d6 100644
--- a/examples/parsers/json.c
+++ b/examples/parsers/json.c
@@ -12,7 +12,6 @@ enum {
     ts_sym_left_bracket,
     ts_sym_right_brace,
     ts_sym_right_bracket,
-    ts_aux_sym_end,
     ts_aux_sym_repeat_helper1,
     ts_aux_sym_repeat_helper2,
 };
@@ -29,7 +28,6 @@ SYMBOL_NAMES {
     "left_bracket",
     "right_brace",
     "right_bracket",
-    "end",
     "repeat_helper1",
     "repeat_helper2",
 };
@@ -61,166 +59,160 @@ LEX_FN() {
     START_LEXER();
     switch (LEX_STATE()) {
         case 0:
-            if (LOOKAHEAD_CHAR() == '\0')
-                ADVANCE(1);
             LEX_ERROR();
         case 1:
-            ACCEPT_TOKEN(ts_aux_sym_end);
-        case 2:
             if (LOOKAHEAD_CHAR() == ',')
+                ADVANCE(2);
+            if (LOOKAHEAD_CHAR() == '}')
                 ADVANCE(3);
-            if (LOOKAHEAD_CHAR() == '}')
-                ADVANCE(4);
             LEX_ERROR();
-        case 3:
+        case 2:
             ACCEPT_TOKEN(ts_sym_comma);
-        case 4:
+        case 3:
             ACCEPT_TOKEN(ts_sym_right_brace);
-        case 5:
+        case 4:
             if (LOOKAHEAD_CHAR() == '}')
-                ADVANCE(4);
+                ADVANCE(3);
+            LEX_ERROR();
+        case 5:
+            if (LOOKAHEAD_CHAR() == ',')
+                ADVANCE(2);
+            if (LOOKAHEAD_CHAR() == ']')
+                ADVANCE(6);
             LEX_ERROR();
         case 6:
-            if (LOOKAHEAD_CHAR() == ',')
-                ADVANCE(3);
-            if (LOOKAHEAD_CHAR() == ']')
-                ADVANCE(7);
-            LEX_ERROR();
-        case 7:
             ACCEPT_TOKEN(ts_sym_right_bracket);
-        case 8:
+        case 7:
             if (LOOKAHEAD_CHAR() == ']')
-                ADVANCE(7);
+                ADVANCE(6);
+            LEX_ERROR();
+        case 8:
+            if (LOOKAHEAD_CHAR() == '\"')
+                ADVANCE(9);
+            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
+                ADVANCE(15);
+            if (LOOKAHEAD_CHAR() == '[')
+                ADVANCE(16);
+            if (LOOKAHEAD_CHAR() == '{')
+                ADVANCE(17);
             LEX_ERROR();
         case 9:
-            if (LOOKAHEAD_CHAR() == '\"')
+            if (!((LOOKAHEAD_CHAR() == '\"') ||
+                (LOOKAHEAD_CHAR() == '\\')))
                 ADVANCE(10);
-            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(16);
-            if (LOOKAHEAD_CHAR() == '[')
-                ADVANCE(17);
-            if (LOOKAHEAD_CHAR() == '{')
-                ADVANCE(18);
+            if (LOOKAHEAD_CHAR() == '\"')
+                ADVANCE(11);
+            if (LOOKAHEAD_CHAR() == '\\')
+                ADVANCE(12);
+            if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
+                ADVANCE(14);
             LEX_ERROR();
         case 10:
             if (!((LOOKAHEAD_CHAR() == '\"') ||
                 (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(11);
+                ADVANCE(10);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(12);
+                ADVANCE(11);
             if (LOOKAHEAD_CHAR() == '\\')
-                ADVANCE(13);
+                ADVANCE(12);
             if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(15);
+                ADVANCE(14);
             LEX_ERROR();
         case 11:
+            ACCEPT_TOKEN(ts_sym_string);
+        case 12:
             if (!((LOOKAHEAD_CHAR() == '\"') ||
                 (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(11);
+                ADVANCE(10);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(12);
-            if (LOOKAHEAD_CHAR() == '\\')
                 ADVANCE(13);
+            if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"')
+                ADVANCE(10);
+            if (LOOKAHEAD_CHAR() == '\\')
+                ADVANCE(12);
             if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(15);
+                ADVANCE(14);
             LEX_ERROR();
-        case 12:
-            ACCEPT_TOKEN(ts_sym_string);
         case 13:
             if (!((LOOKAHEAD_CHAR() == '\"') ||
                 (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(11);
+                ADVANCE(10);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(14);
-            if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"')
                 ADVANCE(11);
             if (LOOKAHEAD_CHAR() == '\\')
-                ADVANCE(13);
-            if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(15);
-            LEX_ERROR();
-        case 14:
-            if (!((LOOKAHEAD_CHAR() == '\"') ||
-                (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(11);
-            if (LOOKAHEAD_CHAR() == '\"')
                 ADVANCE(12);
-            if (LOOKAHEAD_CHAR() == '\\')
-                ADVANCE(13);
             if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(15);
+                ADVANCE(14);
             ACCEPT_TOKEN(ts_sym_string);
-        case 15:
-            if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(11);
-            LEX_ERROR();
-        case 16:
-            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(16);
-            ACCEPT_TOKEN(ts_sym_number);
-        case 17:
-            ACCEPT_TOKEN(ts_sym_left_bracket);
-        case 18:
-            ACCEPT_TOKEN(ts_sym_left_brace);
-        case 19:
-            if (LOOKAHEAD_CHAR() == ':')
-                ADVANCE(20);
-            LEX_ERROR();
-        case 20:
-            ACCEPT_TOKEN(ts_sym_colon);
-        case 21:
+        case 14:
             if (LOOKAHEAD_CHAR() == '\"')
                 ADVANCE(10);
+            LEX_ERROR();
+        case 15:
+            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
+                ADVANCE(15);
+            ACCEPT_TOKEN(ts_sym_number);
+        case 16:
+            ACCEPT_TOKEN(ts_sym_left_bracket);
+        case 17:
+            ACCEPT_TOKEN(ts_sym_left_brace);
+        case 18:
+            if (LOOKAHEAD_CHAR() == ':')
+                ADVANCE(19);
+            LEX_ERROR();
+        case 19:
+            ACCEPT_TOKEN(ts_sym_colon);
+        case 20:
+            if (LOOKAHEAD_CHAR() == '\"')
+                ADVANCE(9);
             if (LOOKAHEAD_CHAR() == '}')
-                ADVANCE(4);
+                ADVANCE(3);
+            LEX_ERROR();
+        case 21:
+            if (LOOKAHEAD_CHAR() == '\"')
+                ADVANCE(9);
+            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
+                ADVANCE(15);
+            if (LOOKAHEAD_CHAR() == '[')
+                ADVANCE(16);
+            if (LOOKAHEAD_CHAR() == ']')
+                ADVANCE(6);
+            if (LOOKAHEAD_CHAR() == '{')
+                ADVANCE(17);
             LEX_ERROR();
         case 22:
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(10);
-            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(16);
-            if (LOOKAHEAD_CHAR() == '[')
-                ADVANCE(17);
-            if (LOOKAHEAD_CHAR() == ']')
-                ADVANCE(7);
-            if (LOOKAHEAD_CHAR() == '{')
-                ADVANCE(18);
+                ADVANCE(9);
             LEX_ERROR();
         case 23:
-            if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(10);
-            LEX_ERROR();
-        case 24:
             ACCEPT_TOKEN(ts_sym_comma);
-        case 25:
+        case 24:
             ACCEPT_TOKEN(ts_sym_colon);
-        case 26:
+        case 25:
             ACCEPT_TOKEN(ts_sym_left_bracket);
-        case 27:
+        case 26:
             ACCEPT_TOKEN(ts_sym_right_bracket);
-        case 28:
+        case 27:
             ACCEPT_TOKEN(ts_sym_left_brace);
-        case 29:
+        case 28:
             ACCEPT_TOKEN(ts_sym_right_brace);
         case ts_lex_state_error:
-            if (LOOKAHEAD_CHAR() == '\0')
-                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(10);
+                ADVANCE(9);
             if (LOOKAHEAD_CHAR() == ',')
-                ADVANCE(24);
+                ADVANCE(23);
             if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(16);
+                ADVANCE(15);
             if (LOOKAHEAD_CHAR() == ':')
-                ADVANCE(25);
+                ADVANCE(24);
             if (LOOKAHEAD_CHAR() == '[')
-                ADVANCE(26);
+                ADVANCE(25);
             if (LOOKAHEAD_CHAR() == ']')
-                ADVANCE(27);
+                ADVANCE(26);
             if (LOOKAHEAD_CHAR() == '{')
-                ADVANCE(28);
+                ADVANCE(27);
             if (LOOKAHEAD_CHAR() == '}')
-                ADVANCE(29);
+                ADVANCE(28);
             LEX_ERROR();
         default:
             LEX_PANIC();
@@ -232,7 +224,7 @@ PARSE_FN() {
     START_PARSER();
     switch (PARSE_STATE()) {
         case 0:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(1);
@@ -254,21 +246,21 @@ PARSE_FN() {
         case 1:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_value, 1, COLLAPSE({0}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 2:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     ACCEPT_INPUT();
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 3:
-            SET_LEX_STATE(21);
+            SET_LEX_STATE(20);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(4);
@@ -280,7 +272,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_string, ts_sym_right_brace, ts_builtin_sym_error}));
             }
         case 4:
-            SET_LEX_STATE(19);
+            SET_LEX_STATE(18);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(5);
@@ -288,7 +280,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 5:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -308,7 +300,7 @@ PARSE_FN() {
                     PARSE_ERROR(7, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket}));
             }
         case 6:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_value, 1, COLLAPSE({0}));
@@ -318,7 +310,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 7:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -330,7 +322,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 8:
-            SET_LEX_STATE(23);
+            SET_LEX_STATE(22);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(9);
@@ -340,7 +332,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_string, ts_builtin_sym_error}));
             }
         case 9:
-            SET_LEX_STATE(19);
+            SET_LEX_STATE(18);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(10);
@@ -348,7 +340,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 10:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -368,7 +360,7 @@ PARSE_FN() {
                     PARSE_ERROR(7, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket}));
             }
         case 11:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -380,7 +372,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 12:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     REDUCE(ts_aux_sym_repeat_helper2, 5, COLLAPSE({1, 0, 1, 0, 1}));
@@ -388,7 +380,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 13:
-            SET_LEX_STATE(21);
+            SET_LEX_STATE(20);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(14);
@@ -400,7 +392,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_string, ts_sym_right_brace, ts_builtin_sym_error}));
             }
         case 14:
-            SET_LEX_STATE(19);
+            SET_LEX_STATE(18);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(15);
@@ -408,7 +400,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 15:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -428,7 +420,7 @@ PARSE_FN() {
                     PARSE_ERROR(7, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket}));
             }
         case 16:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -440,7 +432,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 17:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(18);
@@ -448,7 +440,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 18:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
@@ -458,7 +450,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 19:
-            SET_LEX_STATE(22);
+            SET_LEX_STATE(21);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -482,7 +474,7 @@ PARSE_FN() {
                     PARSE_ERROR(9, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket, ts_sym_right_bracket, ts_builtin_sym_error}));
             }
         case 20:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_value, 1, COLLAPSE({0}));
@@ -492,7 +484,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 21:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -504,7 +496,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 22:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -526,7 +518,7 @@ PARSE_FN() {
                     PARSE_ERROR(8, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket, ts_builtin_sym_error}));
             }
         case 23:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -538,7 +530,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 24:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(7);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     REDUCE(ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1}));
@@ -546,7 +538,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_bracket}));
             }
         case 25:
-            SET_LEX_STATE(21);
+            SET_LEX_STATE(20);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(26);
@@ -558,7 +550,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_string, ts_sym_right_brace, ts_builtin_sym_error}));
             }
         case 26:
-            SET_LEX_STATE(19);
+            SET_LEX_STATE(18);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(27);
@@ -566,7 +558,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 27:
-            SET_LEX_STATE(9);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -586,7 +578,7 @@ PARSE_FN() {
                     PARSE_ERROR(7, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket}));
             }
         case 28:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -598,7 +590,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 29:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(30);
@@ -606,7 +598,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 30:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
@@ -616,7 +608,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 31:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
@@ -626,7 +618,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 32:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -638,7 +630,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 33:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(34);
@@ -646,7 +638,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 34:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}));
@@ -656,7 +648,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 35:
-            SET_LEX_STATE(22);
+            SET_LEX_STATE(21);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -680,7 +672,7 @@ PARSE_FN() {
                     PARSE_ERROR(9, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket, ts_sym_right_bracket, ts_builtin_sym_error}));
             }
         case 36:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -692,7 +684,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 37:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(7);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     SHIFT(38);
@@ -700,7 +692,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_bracket}));
             }
         case 38:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
@@ -710,7 +702,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 39:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
@@ -720,7 +712,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 40:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(7);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     SHIFT(41);
@@ -728,7 +720,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_bracket}));
             }
         case 41:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
@@ -738,7 +730,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 42:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
@@ -748,7 +740,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 43:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
@@ -758,7 +750,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 44:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -770,7 +762,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 45:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(46);
@@ -778,7 +770,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 46:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}));
@@ -788,7 +780,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 47:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -800,7 +792,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 48:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     REDUCE(ts_aux_sym_repeat_helper2, 3, COLLAPSE({1, 0, 1}));
@@ -808,7 +800,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 49:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(50);
@@ -818,21 +810,21 @@ PARSE_FN() {
         case 50:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 51:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 52:
-            SET_LEX_STATE(2);
+            SET_LEX_STATE(1);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -844,7 +836,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 53:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(54);
@@ -854,13 +846,13 @@ PARSE_FN() {
         case 54:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 55:
-            SET_LEX_STATE(22);
+            SET_LEX_STATE(21);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -884,7 +876,7 @@ PARSE_FN() {
                     PARSE_ERROR(9, EXPECT({ts_sym_array, ts_sym_number, ts_sym_object, ts_sym_string, ts_sym_value, ts_sym_left_brace, ts_sym_left_bracket, ts_sym_right_bracket, ts_builtin_sym_error}));
             }
         case 56:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -896,7 +888,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 57:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(7);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     SHIFT(58);
@@ -906,18 +898,18 @@ PARSE_FN() {
         case 58:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         case 59:
             SET_LEX_STATE(0);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_sym_end:
+                case ts_builtin_sym_end:
                     REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
                 default:
-                    PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
+                    PARSE_ERROR(1, EXPECT({ts_builtin_sym_end}));
             }
         default:
             PARSE_PANIC();
diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h
index 4c6b5d82..70027a1c 100644
--- a/include/tree_sitter/parser.h
+++ b/include/tree_sitter/parser.h
@@ -197,6 +197,10 @@ next_state:
 
 #define START_LEXER() \
 ts_parser_skip_whitespace(parser); \
+if (!ts_parser_lookahead_char(parser)) { \
+    parser->lookahead_node = ts_tree_make_leaf(ts_builtin_sym_end); \
+    return; \
+} \
 next_state:
 
 #define LOOKAHEAD_SYM() \
diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h
index 51c4880f..2f6e2cfa 100644
--- a/include/tree_sitter/runtime.h
+++ b/include/tree_sitter/runtime.h
@@ -9,6 +9,7 @@ extern "C" {
 
 typedef int ts_symbol;
 static const ts_symbol ts_builtin_sym_error = -1;
+static const ts_symbol ts_builtin_sym_end = -2;
     
 typedef struct ts_tree {
     ts_symbol symbol;
diff --git a/src/compiler/build_tables/perform.cpp b/src/compiler/build_tables/perform.cpp
index 4d320307..1ca06bc9 100644
--- a/src/compiler/build_tables/perform.cpp
+++ b/src/compiler/build_tables/perform.cpp
@@ -17,9 +17,6 @@ namespace tree_sitter {
 
     namespace build_tables {
         const int NOT_FOUND = -2;
-        const Symbol START("start", rules::SymbolTypeAuxiliary);
-        const Symbol END_OF_INPUT("end", rules::SymbolTypeAuxiliary);
-        const LexItem EOF_ITEM(END_OF_INPUT, make_shared<CharacterSet>(std::set<rules::CharacterRange>{ '\0' }));
 
         class TableBuilder {
             const PreparedGrammar grammar;
@@ -72,7 +69,7 @@ namespace tree_sitter {
             void add_reduce_actions(const ParseItemSet &item_set, ParseStateId state_id) {
                 for (ParseItem item : item_set) {
                     if (item.is_done()) {
-                        ParseAction action = (item.lhs == START) ?
+                        ParseAction action = (item.lhs == rules::START) ?
                             ParseAction::Accept() :
                             ParseAction::Reduce(item.lhs, item.consumed_symbols);
                         parse_table.add_action(state_id, item.lookahead_sym, action);
@@ -86,8 +83,6 @@ namespace tree_sitter {
                 for (auto &symbol : state.expected_inputs()) {
                     if (lex_grammar.has_definition(symbol))
                         item_set.insert(LexItem(symbol, lex_grammar.rule(symbol)));
-                    else if (symbol == END_OF_INPUT)
-                        item_set.insert(EOF_ITEM);
                 }
 
                 state.lex_state_id = add_lex_state(item_set);
@@ -121,7 +116,6 @@ namespace tree_sitter {
                 LexItemSet error_item_set;
                 for (auto &pair : lex_grammar.rules)
                     error_item_set.insert(LexItem(pair.first, pair.second));
-                error_item_set.insert(EOF_ITEM);
                 add_advance_actions(error_item_set, LexTable::ERROR_STATE_ID);
                 add_accept_token_actions(error_item_set, LexTable::ERROR_STATE_ID);
             }
@@ -148,7 +142,7 @@ namespace tree_sitter {
                 lex_grammar(lex_grammar) {};
 
             pair<ParseTable, LexTable> build() {
-                ParseItem item(START, make_shared<Symbol>(grammar.start_rule_name), {}, END_OF_INPUT);
+                ParseItem item(rules::START, make_shared<Symbol>(grammar.start_rule_name), {}, rules::END_OF_INPUT);
                 ParseItemSet item_set = item_set_closure(ParseItemSet({ item }), grammar);
                 add_parse_state(item_set);
                 add_error_lex_state();
diff --git a/src/compiler/generate_code/c_code.cpp b/src/compiler/generate_code/c_code.cpp
index 5cfde752..9b1ad079 100644
--- a/src/compiler/generate_code/c_code.cpp
+++ b/src/compiler/generate_code/c_code.cpp
@@ -59,7 +59,7 @@ namespace tree_sitter {
                     if (symbol == rules::ERROR)
                         return "ts_builtin_sym_error";
                     else
-                        return "unexpected_built_in_sym!";
+                        return "ts_builtin_sym_end";
                 } else if (symbol.is_auxiliary())
                     return "ts_aux_sym_" + symbol.name;
                 else
diff --git a/src/compiler/rules/built_in_symbols.cpp b/src/compiler/rules/built_in_symbols.cpp
index 3d2dbd33..20bd5cc6 100644
--- a/src/compiler/rules/built_in_symbols.cpp
+++ b/src/compiler/rules/built_in_symbols.cpp
@@ -3,5 +3,7 @@
 namespace tree_sitter {
     namespace rules {
         const Symbol ERROR("error", SymbolTypeBuiltIn);
+        const Symbol START("start", SymbolTypeBuiltIn);
+        const Symbol END_OF_INPUT("end", SymbolTypeBuiltIn);
     }
 }
\ No newline at end of file
diff --git a/src/compiler/rules/built_in_symbols.h b/src/compiler/rules/built_in_symbols.h
index 4c774ac5..2d3899ba 100644
--- a/src/compiler/rules/built_in_symbols.h
+++ b/src/compiler/rules/built_in_symbols.h
@@ -6,6 +6,8 @@
 namespace tree_sitter {
     namespace rules {
         extern const Symbol ERROR;
+        extern const Symbol START;
+        extern const Symbol END_OF_INPUT;
     }
 }
 
diff --git a/tree_sitter.xcodeproj/project.pbxproj b/tree_sitter.xcodeproj/project.pbxproj
index 6308056a..99538bb7 100644
--- a/tree_sitter.xcodeproj/project.pbxproj
+++ b/tree_sitter.xcodeproj/project.pbxproj
@@ -103,6 +103,7 @@
 		122587B018BDD79600A68B84 /* follow_sets_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = follow_sets_spec.cpp; sourceTree = "<group>"; };
 		122587B218BEE2C600A68B84 /* helpers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = helpers.cpp; sourceTree = "<group>"; };
 		122587B318BEE2C600A68B84 /* helpers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = helpers.h; sourceTree = "<group>"; };
+		122587B518BF19CA00A68B84 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = README.md; sourceTree = "<group>"; };
 		1225CC6318765693000D4723 /* prepare_grammar_spec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = prepare_grammar_spec.cpp; sourceTree = "<group>"; };
 		1236A7C318B287DC00593ABB /* character_range.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = character_range.cpp; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.cpp; };
 		1236A7C918B2A79F00593ABB /* rule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rule.h; sourceTree = "<group>"; };
@@ -312,6 +313,7 @@
 				12FD40D3185FED630041A84E /* include */,
 				1236A7CC18B2B4F000593ABB /* Makefile */,
 				12E71795181D02A80051A649 /* Products */,
+				122587B518BF19CA00A68B84 /* README.md */,
 				12E71796181D02A80051A649 /* spec */,
 				12E71701181D01890051A649 /* src */,
 				12D1369E18342088005F3369 /* todo.md */,