diff --git a/examples/parsers/arithmetic.c b/examples/parsers/arithmetic.c
index 6f169dce..7664dfa7 100644
--- a/examples/parsers/arithmetic.c
+++ b/examples/parsers/arithmetic.c
@@ -30,81 +30,93 @@ LEX_FN() {
     START_LEXER();
     switch (LEX_STATE()) {
         case 0:
+            if (LOOKAHEAD_CHAR() == '\0')
+                ADVANCE(1);
             LEX_ERROR();
         case 1:
-            if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(2);
-            LEX_ERROR();
+            ACCEPT_TOKEN(ts_aux_sym_end);
         case 2:
-            ACCEPT_TOKEN(ts_sym_plus);
-        case 3:
-            if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(4);
-            LEX_ERROR();
-        case 4:
-            ACCEPT_TOKEN(ts_aux_sym_token2);
-        case 5:
-            if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(4);
+            if (LOOKAHEAD_CHAR() == '\0')
+                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(2);
+                ADVANCE(3);
             LEX_ERROR();
+        case 3:
+            ACCEPT_TOKEN(ts_sym_plus);
+        case 4:
+            if (LOOKAHEAD_CHAR() == ')')
+                ADVANCE(5);
+            LEX_ERROR();
+        case 5:
+            ACCEPT_TOKEN(ts_aux_sym_token2);
         case 6:
             if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(4);
-            if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(7);
+                ADVANCE(5);
             if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(2);
+                ADVANCE(3);
             LEX_ERROR();
         case 7:
-            ACCEPT_TOKEN(ts_sym_times);
-        case 8:
-            if (LOOKAHEAD_CHAR() == '(')
-                ADVANCE(9);
-            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(10);
-            if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
-                ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
-                ADVANCE(11);
-            LEX_ERROR();
-        case 9:
-            ACCEPT_TOKEN(ts_aux_sym_token1);
-        case 10:
-            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(10);
-            ACCEPT_TOKEN(ts_sym_number);
-        case 11:
-            if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
-                ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
-                ADVANCE(11);
-            ACCEPT_TOKEN(ts_sym_variable);
-        case 12:
             if (LOOKAHEAD_CHAR() == ')')
-                ADVANCE(4);
+                ADVANCE(5);
             if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(7);
-            LEX_ERROR();
-        case 13:
-            if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(7);
+                ADVANCE(8);
             if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(2);
+                ADVANCE(3);
+            LEX_ERROR();
+        case 8:
+            ACCEPT_TOKEN(ts_sym_times);
+        case 9:
+            if (LOOKAHEAD_CHAR() == '(')
+                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);
+            LEX_ERROR();
+        case 10:
+            ACCEPT_TOKEN(ts_aux_sym_token1);
+        case 11:
+            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
+                ADVANCE(11);
+            ACCEPT_TOKEN(ts_sym_number);
+        case 12:
+            if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
+                ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
+                ADVANCE(12);
+            ACCEPT_TOKEN(ts_sym_variable);
+        case 13:
+            if (LOOKAHEAD_CHAR() == ')')
+                ADVANCE(5);
+            if (LOOKAHEAD_CHAR() == '*')
+                ADVANCE(8);
             LEX_ERROR();
         case 14:
+            if (LOOKAHEAD_CHAR() == '\0')
+                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(7);
+                ADVANCE(8);
+            if (LOOKAHEAD_CHAR() == '+')
+                ADVANCE(3);
+            LEX_ERROR();
+        case 15:
+            if (LOOKAHEAD_CHAR() == '\0')
+                ADVANCE(1);
+            if (LOOKAHEAD_CHAR() == '*')
+                ADVANCE(8);
             LEX_ERROR();
         case ts_lex_state_error:
+            if (LOOKAHEAD_CHAR() == '\0')
+                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '*')
-                ADVANCE(7);
+                ADVANCE(8);
             if (LOOKAHEAD_CHAR() == '+')
-                ADVANCE(2);
+                ADVANCE(3);
             if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(10);
+                ADVANCE(11);
             if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
                 ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
-                ADVANCE(11);
+                ADVANCE(12);
             LEX_ERROR();
         default:
             LEX_PANIC();
@@ -116,7 +128,7 @@ PARSE_FN() {
     START_PARSER();
     switch (PARSE_STATE()) {
         case 0:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(1);
@@ -142,7 +154,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
             }
         case 2:
-            SET_LEX_STATE(13);
+            SET_LEX_STATE(14);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 1, COLLAPSE({0}));
@@ -154,7 +166,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_end}));
             }
         case 3:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(4);
@@ -168,7 +180,7 @@ PARSE_FN() {
                     PARSE_ERROR(4, EXPECT({ts_sym_factor, ts_sym_number, ts_sym_variable, ts_aux_sym_token1}));
             }
         case 4:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
@@ -178,7 +190,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
             }
         case 5:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -188,7 +200,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
             }
         case 6:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(7);
@@ -206,7 +218,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(8);
@@ -214,7 +226,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 8:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -224,7 +236,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
             }
         case 9:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(7);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 1, COLLAPSE({0}));
@@ -236,7 +248,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_token2}));
             }
         case 10:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(11);
@@ -250,7 +262,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(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
@@ -260,7 +272,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 12:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -270,7 +282,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 13:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(14);
@@ -288,7 +300,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(15);
@@ -296,7 +308,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 15:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -306,7 +318,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 16:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(7);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -318,7 +330,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_token2}));
             }
         case 17:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     SHIFT(18);
@@ -328,7 +340,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_token2}));
             }
         case 18:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(19);
@@ -344,7 +356,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(12);
+            SET_LEX_STATE(13);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     SHIFT(20);
@@ -354,7 +366,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_token2}));
             }
         case 20:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(21);
@@ -368,7 +380,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_term, 3, COLLAPSE({0, 0, 0}));
@@ -376,7 +388,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 22:
-            SET_LEX_STATE(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -384,7 +396,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 23:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(24);
@@ -402,7 +414,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(25);
@@ -410,7 +422,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 25:
-            SET_LEX_STATE(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -418,7 +430,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 26:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(27);
@@ -436,7 +448,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(28);
@@ -444,7 +456,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 28:
-            SET_LEX_STATE(6);
+            SET_LEX_STATE(7);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -456,7 +468,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_token2}));
             }
         case 29:
-            SET_LEX_STATE(12);
+            SET_LEX_STATE(13);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -466,7 +478,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_token2}));
             }
         case 30:
-            SET_LEX_STATE(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     REDUCE(ts_sym_expression, 3, COLLAPSE({0, 0, 0}));
@@ -474,7 +486,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 31:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(32);
@@ -492,7 +504,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(33);
@@ -500,7 +512,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 33:
-            SET_LEX_STATE(12);
+            SET_LEX_STATE(13);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -510,7 +522,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_token2}));
             }
         case 34:
-            SET_LEX_STATE(13);
+            SET_LEX_STATE(14);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -522,7 +534,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_plus, ts_sym_times, ts_aux_sym_end}));
             }
         case 35:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     SHIFT(36);
@@ -532,7 +544,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_plus, ts_aux_sym_end}));
             }
         case 36:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(37);
@@ -548,7 +560,7 @@ 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(14);
+            SET_LEX_STATE(15);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     SHIFT(38);
@@ -558,7 +570,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_end}));
             }
         case 38:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_factor:
                     SHIFT(39);
@@ -588,7 +600,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
             }
         case 41:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(42);
@@ -606,7 +618,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(43);
@@ -622,7 +634,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
             }
         case 44:
-            SET_LEX_STATE(14);
+            SET_LEX_STATE(15);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 1, COLLAPSE({0}));
@@ -640,7 +652,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
             }
         case 46:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(47);
@@ -658,7 +670,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(48);
@@ -666,7 +678,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 48:
-            SET_LEX_STATE(14);
+            SET_LEX_STATE(15);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_times:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
@@ -676,7 +688,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_times, ts_aux_sym_end}));
             }
         case 49:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_expression:
                     SHIFT(50);
@@ -694,7 +706,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(3);
+            SET_LEX_STATE(4);
             switch (LOOKAHEAD_SYM()) {
                 case ts_aux_sym_token2:
                     SHIFT(51);
@@ -702,7 +714,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_token2}));
             }
         case 51:
-            SET_LEX_STATE(13);
+            SET_LEX_STATE(14);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_plus:
                     REDUCE(ts_sym_factor, 3, COLLAPSE({1, 0, 1}));
diff --git a/examples/parsers/json.c b/examples/parsers/json.c
index ba7dfe57..402569ec 100644
--- a/examples/parsers/json.c
+++ b/examples/parsers/json.c
@@ -38,160 +38,166 @@ LEX_FN() {
     START_LEXER();
     switch (LEX_STATE()) {
         case 0:
+            if (LOOKAHEAD_CHAR() == '\0')
+                ADVANCE(1);
             LEX_ERROR();
         case 1:
-            if (LOOKAHEAD_CHAR() == ',')
-                ADVANCE(2);
-            if (LOOKAHEAD_CHAR() == '}')
-                ADVANCE(3);
-            LEX_ERROR();
+            ACCEPT_TOKEN(ts_aux_sym_end);
         case 2:
-            ACCEPT_TOKEN(ts_sym_comma);
-        case 3:
-            ACCEPT_TOKEN(ts_sym_right_brace);
-        case 4:
-            if (LOOKAHEAD_CHAR() == '}')
-                ADVANCE(3);
-            LEX_ERROR();
-        case 5:
             if (LOOKAHEAD_CHAR() == ',')
-                ADVANCE(2);
-            if (LOOKAHEAD_CHAR() == ']')
-                ADVANCE(6);
+                ADVANCE(3);
+            if (LOOKAHEAD_CHAR() == '}')
+                ADVANCE(4);
+            LEX_ERROR();
+        case 3:
+            ACCEPT_TOKEN(ts_sym_comma);
+        case 4:
+            ACCEPT_TOKEN(ts_sym_right_brace);
+        case 5:
+            if (LOOKAHEAD_CHAR() == '}')
+                ADVANCE(4);
             LEX_ERROR();
         case 6:
-            ACCEPT_TOKEN(ts_sym_right_bracket);
-        case 7:
+            if (LOOKAHEAD_CHAR() == ',')
+                ADVANCE(3);
             if (LOOKAHEAD_CHAR() == ']')
-                ADVANCE(6);
+                ADVANCE(7);
             LEX_ERROR();
+        case 7:
+            ACCEPT_TOKEN(ts_sym_right_bracket);
         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);
+            if (LOOKAHEAD_CHAR() == ']')
+                ADVANCE(7);
             LEX_ERROR();
         case 9:
-            if (!((LOOKAHEAD_CHAR() == '\"') ||
-                (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(10);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(11);
-            if (LOOKAHEAD_CHAR() == '\\')
-                ADVANCE(12);
-            if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(14);
+                ADVANCE(10);
+            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
+                ADVANCE(16);
+            if (LOOKAHEAD_CHAR() == '[')
+                ADVANCE(17);
+            if (LOOKAHEAD_CHAR() == '{')
+                ADVANCE(18);
             LEX_ERROR();
         case 10:
             if (!((LOOKAHEAD_CHAR() == '\"') ||
                 (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(10);
-            if (LOOKAHEAD_CHAR() == '\"')
                 ADVANCE(11);
-            if (LOOKAHEAD_CHAR() == '\\')
+            if (LOOKAHEAD_CHAR() == '\"')
                 ADVANCE(12);
+            if (LOOKAHEAD_CHAR() == '\\')
+                ADVANCE(13);
             if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(14);
+                ADVANCE(15);
             LEX_ERROR();
         case 11:
-            ACCEPT_TOKEN(ts_sym_string);
-        case 12:
             if (!((LOOKAHEAD_CHAR() == '\"') ||
                 (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(10);
+                ADVANCE(11);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(13);
-            if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"')
-                ADVANCE(10);
-            if (LOOKAHEAD_CHAR() == '\\')
                 ADVANCE(12);
+            if (LOOKAHEAD_CHAR() == '\\')
+                ADVANCE(13);
             if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(14);
+                ADVANCE(15);
             LEX_ERROR();
+        case 12:
+            ACCEPT_TOKEN(ts_sym_string);
         case 13:
             if (!((LOOKAHEAD_CHAR() == '\"') ||
                 (LOOKAHEAD_CHAR() == '\\')))
-                ADVANCE(10);
+                ADVANCE(11);
             if (LOOKAHEAD_CHAR() == '\"')
+                ADVANCE(14);
+            if ('#' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\"')
                 ADVANCE(11);
             if (LOOKAHEAD_CHAR() == '\\')
-                ADVANCE(12);
+                ADVANCE(13);
             if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
-                ADVANCE(14);
-            ACCEPT_TOKEN(ts_sym_string);
-        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:
+        case 14:
+            if (!((LOOKAHEAD_CHAR() == '\"') ||
+                (LOOKAHEAD_CHAR() == '\\')))
+                ADVANCE(11);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(9);
-            if (LOOKAHEAD_CHAR() == '}')
-                ADVANCE(3);
+                ADVANCE(12);
+            if (LOOKAHEAD_CHAR() == '\\')
+                ADVANCE(13);
+            if (']' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '\\')
+                ADVANCE(15);
+            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:
             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);
+                ADVANCE(10);
+            if (LOOKAHEAD_CHAR() == '}')
+                ADVANCE(4);
             LEX_ERROR();
         case 22:
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(9);
+                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);
             LEX_ERROR();
         case 23:
-            ACCEPT_TOKEN(ts_sym_comma);
+            if (LOOKAHEAD_CHAR() == '\"')
+                ADVANCE(10);
+            LEX_ERROR();
         case 24:
-            ACCEPT_TOKEN(ts_sym_colon);
+            ACCEPT_TOKEN(ts_sym_comma);
         case 25:
-            ACCEPT_TOKEN(ts_sym_left_bracket);
+            ACCEPT_TOKEN(ts_sym_colon);
         case 26:
-            ACCEPT_TOKEN(ts_sym_right_bracket);
+            ACCEPT_TOKEN(ts_sym_left_bracket);
         case 27:
-            ACCEPT_TOKEN(ts_sym_left_brace);
+            ACCEPT_TOKEN(ts_sym_right_bracket);
         case 28:
+            ACCEPT_TOKEN(ts_sym_left_brace);
+        case 29:
             ACCEPT_TOKEN(ts_sym_right_brace);
         case ts_lex_state_error:
+            if (LOOKAHEAD_CHAR() == '\0')
+                ADVANCE(1);
             if (LOOKAHEAD_CHAR() == '\"')
-                ADVANCE(9);
+                ADVANCE(10);
             if (LOOKAHEAD_CHAR() == ',')
-                ADVANCE(23);
-            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
-                ADVANCE(15);
-            if (LOOKAHEAD_CHAR() == ':')
                 ADVANCE(24);
-            if (LOOKAHEAD_CHAR() == '[')
+            if ('0' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= '9')
+                ADVANCE(16);
+            if (LOOKAHEAD_CHAR() == ':')
                 ADVANCE(25);
-            if (LOOKAHEAD_CHAR() == ']')
+            if (LOOKAHEAD_CHAR() == '[')
                 ADVANCE(26);
-            if (LOOKAHEAD_CHAR() == '{')
+            if (LOOKAHEAD_CHAR() == ']')
                 ADVANCE(27);
-            if (LOOKAHEAD_CHAR() == '}')
+            if (LOOKAHEAD_CHAR() == '{')
                 ADVANCE(28);
+            if (LOOKAHEAD_CHAR() == '}')
+                ADVANCE(29);
             LEX_ERROR();
         default:
             LEX_PANIC();
@@ -203,7 +209,7 @@ PARSE_FN() {
     START_PARSER();
     switch (PARSE_STATE()) {
         case 0:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(1);
@@ -239,7 +245,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
             }
         case 3:
-            SET_LEX_STATE(20);
+            SET_LEX_STATE(21);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(4);
@@ -249,7 +255,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_string, ts_sym_right_brace}));
             }
         case 4:
-            SET_LEX_STATE(18);
+            SET_LEX_STATE(19);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(5);
@@ -257,7 +263,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 5:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -277,7 +283,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(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_value, 1, COLLAPSE({0}));
@@ -287,7 +293,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 7:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -299,7 +305,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 8:
-            SET_LEX_STATE(22);
+            SET_LEX_STATE(23);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(9);
@@ -307,7 +313,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_string}));
             }
         case 9:
-            SET_LEX_STATE(18);
+            SET_LEX_STATE(19);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(10);
@@ -315,7 +321,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 10:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -335,7 +341,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(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -347,7 +353,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 12:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     REDUCE(ts_aux_sym_repeat_helper2, 5, COLLAPSE({1, 0, 1, 0, 1}));
@@ -355,7 +361,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 13:
-            SET_LEX_STATE(20);
+            SET_LEX_STATE(21);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(14);
@@ -365,7 +371,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_string, ts_sym_right_brace}));
             }
         case 14:
-            SET_LEX_STATE(18);
+            SET_LEX_STATE(19);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(15);
@@ -373,7 +379,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 15:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -393,7 +399,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(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -405,7 +411,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 17:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(18);
@@ -413,7 +419,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 18:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
@@ -423,7 +429,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 19:
-            SET_LEX_STATE(21);
+            SET_LEX_STATE(22);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -445,7 +451,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_sym_right_bracket}));
             }
         case 20:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_value, 1, COLLAPSE({0}));
@@ -455,7 +461,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 21:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -467,7 +473,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 22:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -487,7 +493,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 23:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -499,7 +505,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 24:
-            SET_LEX_STATE(7);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     REDUCE(ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1}));
@@ -507,7 +513,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_bracket}));
             }
         case 25:
-            SET_LEX_STATE(20);
+            SET_LEX_STATE(21);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_string:
                     SHIFT(26);
@@ -517,7 +523,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_string, ts_sym_right_brace}));
             }
         case 26:
-            SET_LEX_STATE(18);
+            SET_LEX_STATE(19);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_colon:
                     SHIFT(27);
@@ -525,7 +531,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_colon}));
             }
         case 27:
-            SET_LEX_STATE(8);
+            SET_LEX_STATE(9);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(6);
@@ -545,7 +551,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(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(8);
@@ -557,7 +563,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_brace, ts_aux_sym_repeat_helper2}));
             }
         case 29:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(30);
@@ -565,7 +571,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_brace}));
             }
         case 30:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}));
@@ -575,7 +581,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 31:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
@@ -585,7 +591,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 32:
-            SET_LEX_STATE(21);
+            SET_LEX_STATE(22);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -607,7 +613,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_sym_right_bracket}));
             }
         case 33:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -619,7 +625,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 34:
-            SET_LEX_STATE(7);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     SHIFT(35);
@@ -627,7 +633,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_bracket}));
             }
         case 35:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
@@ -637,7 +643,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 36:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
@@ -647,7 +653,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_bracket}));
             }
         case 37:
-            SET_LEX_STATE(7);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     SHIFT(38);
@@ -655,7 +661,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_sym_right_bracket}));
             }
         case 38:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}));
@@ -665,7 +671,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 39:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_array, 2, COLLAPSE({1, 1}));
@@ -675,7 +681,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 40:
-            SET_LEX_STATE(1);
+            SET_LEX_STATE(2);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     REDUCE(ts_sym_object, 2, COLLAPSE({1, 1}));
@@ -685,7 +691,7 @@ PARSE_FN() {
                     PARSE_ERROR(2, EXPECT({ts_sym_comma, ts_sym_right_brace}));
             }
         case 41:
-            SET_LEX_STATE(4);
+            SET_LEX_STATE(5);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_brace:
                     SHIFT(42);
@@ -709,7 +715,7 @@ PARSE_FN() {
                     PARSE_ERROR(1, EXPECT({ts_aux_sym_end}));
             }
         case 44:
-            SET_LEX_STATE(21);
+            SET_LEX_STATE(22);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_array:
                     SHIFT(20);
@@ -731,7 +737,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_sym_right_bracket}));
             }
         case 45:
-            SET_LEX_STATE(5);
+            SET_LEX_STATE(6);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_comma:
                     SHIFT(22);
@@ -743,7 +749,7 @@ PARSE_FN() {
                     PARSE_ERROR(3, EXPECT({ts_sym_comma, ts_sym_right_bracket, ts_aux_sym_repeat_helper1}));
             }
         case 46:
-            SET_LEX_STATE(7);
+            SET_LEX_STATE(8);
             switch (LOOKAHEAD_SYM()) {
                 case ts_sym_right_bracket:
                     SHIFT(47);
diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h
index 08a20296..b871e993 100644
--- a/include/tree_sitter/parser.h
+++ b/include/tree_sitter/parser.h
@@ -123,7 +123,8 @@ static void ts_parser_reduce(ts_parser *parser, ts_symbol symbol, int immediate_
 
 static void ts_parser_advance(ts_parser *parser, ts_state lex_state) {
     DEBUG_LEX("character: '%c' \n", ts_parser_lookahead_char(parser));
-    parser->position++;
+    if (ts_parser_lookahead_char(parser) != '\0')
+        parser->position++;
     parser->lex_state = lex_state;
 }
 
@@ -174,9 +175,6 @@ ts_parser p = ts_parser_make(input), *parser = &p; \
 next_state:
 
 #define START_LEXER() \
-if (ts_parser_lookahead_char(parser) == '\0') { \
-    ACCEPT_TOKEN(ts_aux_sym_end) \
-} \
 ts_parser_skip_whitespace(parser); \
 next_state:
 
diff --git a/src/compiler/build_tables/perform.cpp b/src/compiler/build_tables/perform.cpp
index c8181de4..ea338863 100644
--- a/src/compiler/build_tables/perform.cpp
+++ b/src/compiler/build_tables/perform.cpp
@@ -14,9 +14,10 @@ namespace tree_sitter {
     using rules::CharacterSet;
 
     namespace build_tables {
-        static int NOT_FOUND = -2;
-        static Symbol START("start", rules::SymbolTypeAuxiliary);
-        static Symbol END_OF_INPUT("end", rules::SymbolTypeAuxiliary);
+        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;
@@ -79,6 +80,8 @@ 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);
@@ -112,6 +115,7 @@ 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);
             }
@@ -138,7 +142,7 @@ namespace tree_sitter {
                 lex_grammar(lex_grammar) {};
 
             pair<ParseTable, LexTable> build() {
-                auto item = ParseItem(START, make_shared<Symbol>(grammar.start_rule_name), {}, END_OF_INPUT);
+                ParseItem item(START, make_shared<Symbol>(grammar.start_rule_name), {}, END_OF_INPUT);
                 ParseItemSet item_set = item_set_closure(ParseItemSet({ item }), grammar);
                 add_parse_state(item_set);
                 add_error_lex_state();