diff --git a/examples/parsers/arithmetic.c b/examples/parsers/arithmetic.c
index b424c25f..4fbc3a3b 100644
--- a/examples/parsers/arithmetic.c
+++ b/examples/parsers/arithmetic.c
@@ -1,5 +1,7 @@
 #include "tree_sitter/parser.h"
 
+#define TS_SYMBOL_COUNT 11
+
 enum {
     ts_sym_expression,
     ts_sym_factor,
@@ -116,7 +118,7 @@ LEX_FN() {
 PARSE_TABLE() {
     START_TABLE(52)
     
-    STATE(0, 11);
+    STATE(0);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 1)
     SHIFT(ts_sym_factor, 2)
@@ -126,19 +128,19 @@ PARSE_TABLE() {
     SHIFT(ts_aux_sym_token1, 49)
     END_STATE();
     
-    STATE(1, 11);
+    STATE(1);
     SET_LEX_STATE(0);
     ACCEPT_INPUT(ts_builtin_sym_end)
     END_STATE();
     
-    STATE(2, 11);
+    STATE(2);
     SET_LEX_STATE(13);
     REDUCE(ts_sym_plus, ts_sym_term, 1, COLLAPSE({0}))
     SHIFT(ts_sym_times, 3)
     REDUCE(ts_builtin_sym_end, ts_sym_term, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(3, 11);
+    STATE(3);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_factor, 4)
     SHIFT(ts_sym_number, 5)
@@ -146,19 +148,19 @@ PARSE_TABLE() {
     SHIFT(ts_aux_sym_token1, 6)
     END_STATE();
     
-    STATE(4, 11);
+    STATE(4);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_plus, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
     REDUCE(ts_builtin_sym_end, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
     END_STATE();
     
-    STATE(5, 11);
+    STATE(5);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(6, 11);
+    STATE(6);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 7)
     SHIFT(ts_sym_factor, 9)
@@ -169,25 +171,25 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 7)
     END_STATE();
     
-    STATE(7, 11);
+    STATE(7);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 8)
     END_STATE();
     
-    STATE(8, 11);
+    STATE(8);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     REDUCE(ts_builtin_sym_end, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(9, 11);
+    STATE(9);
     SET_LEX_STATE(6);
     REDUCE(ts_sym_plus, ts_sym_term, 1, COLLAPSE({0}))
     SHIFT(ts_sym_times, 10)
     REDUCE(ts_aux_sym_token2, ts_sym_term, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(10, 11);
+    STATE(10);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_factor, 11)
     SHIFT(ts_sym_number, 12)
@@ -195,19 +197,19 @@ PARSE_TABLE() {
     SHIFT(ts_aux_sym_token1, 13)
     END_STATE();
     
-    STATE(11, 11);
+    STATE(11);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_plus, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
     REDUCE(ts_aux_sym_token2, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
     END_STATE();
     
-    STATE(12, 11);
+    STATE(12);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(13, 11);
+    STATE(13);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 14)
     SHIFT(ts_sym_factor, 9)
@@ -218,31 +220,31 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 14)
     END_STATE();
     
-    STATE(14, 11);
+    STATE(14);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 15)
     END_STATE();
     
-    STATE(15, 11);
+    STATE(15);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(16, 11);
+    STATE(16);
     SET_LEX_STATE(6);
     REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(17, 11);
+    STATE(17);
     SET_LEX_STATE(5);
     SHIFT(ts_sym_plus, 18)
     REDUCE(ts_aux_sym_token2, ts_sym_expression, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(18, 11);
+    STATE(18);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_factor, 19)
     SHIFT(ts_sym_number, 29)
@@ -251,13 +253,13 @@ PARSE_TABLE() {
     SHIFT(ts_aux_sym_token1, 31)
     END_STATE();
     
-    STATE(19, 11);
+    STATE(19);
     SET_LEX_STATE(12);
     SHIFT(ts_sym_times, 20)
     REDUCE(ts_aux_sym_token2, ts_sym_term, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(20, 11);
+    STATE(20);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_factor, 21)
     SHIFT(ts_sym_number, 22)
@@ -265,17 +267,17 @@ PARSE_TABLE() {
     SHIFT(ts_aux_sym_token1, 23)
     END_STATE();
     
-    STATE(21, 11);
+    STATE(21);
     SET_LEX_STATE(3);
     REDUCE(ts_aux_sym_token2, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
     END_STATE();
     
-    STATE(22, 11);
+    STATE(22);
     SET_LEX_STATE(3);
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(23, 11);
+    STATE(23);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 24)
     SHIFT(ts_sym_factor, 9)
@@ -286,17 +288,17 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 24)
     END_STATE();
     
-    STATE(24, 11);
+    STATE(24);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 25)
     END_STATE();
     
-    STATE(25, 11);
+    STATE(25);
     SET_LEX_STATE(3);
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(26, 11);
+    STATE(26);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 27)
     SHIFT(ts_sym_factor, 9)
@@ -307,30 +309,30 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 27)
     END_STATE();
     
-    STATE(27, 11);
+    STATE(27);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 28)
     END_STATE();
     
-    STATE(28, 11);
+    STATE(28);
     SET_LEX_STATE(6);
     REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(29, 11);
+    STATE(29);
     SET_LEX_STATE(12);
     REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(30, 11);
+    STATE(30);
     SET_LEX_STATE(3);
     REDUCE(ts_aux_sym_token2, ts_sym_expression, 3, COLLAPSE({0, 0, 0}))
     END_STATE();
     
-    STATE(31, 11);
+    STATE(31);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 32)
     SHIFT(ts_sym_factor, 9)
@@ -341,31 +343,31 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 32)
     END_STATE();
     
-    STATE(32, 11);
+    STATE(32);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 33)
     END_STATE();
     
-    STATE(33, 11);
+    STATE(33);
     SET_LEX_STATE(12);
     REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     REDUCE(ts_aux_sym_token2, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(34, 11);
+    STATE(34);
     SET_LEX_STATE(13);
     REDUCE(ts_sym_plus, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(35, 11);
+    STATE(35);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_plus, 36)
     REDUCE(ts_builtin_sym_end, ts_sym_expression, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(36, 11);
+    STATE(36);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_factor, 37)
     SHIFT(ts_sym_number, 44)
@@ -374,13 +376,13 @@ PARSE_TABLE() {
     SHIFT(ts_aux_sym_token1, 46)
     END_STATE();
     
-    STATE(37, 11);
+    STATE(37);
     SET_LEX_STATE(14);
     SHIFT(ts_sym_times, 38)
     REDUCE(ts_builtin_sym_end, ts_sym_term, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(38, 11);
+    STATE(38);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_factor, 39)
     SHIFT(ts_sym_number, 40)
@@ -388,17 +390,17 @@ PARSE_TABLE() {
     SHIFT(ts_aux_sym_token1, 41)
     END_STATE();
     
-    STATE(39, 11);
+    STATE(39);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_term, 3, COLLAPSE({0, 0, 0}))
     END_STATE();
     
-    STATE(40, 11);
+    STATE(40);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(41, 11);
+    STATE(41);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 42)
     SHIFT(ts_sym_factor, 9)
@@ -409,28 +411,28 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 42)
     END_STATE();
     
-    STATE(42, 11);
+    STATE(42);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 43)
     END_STATE();
     
-    STATE(43, 11);
+    STATE(43);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(44, 11);
+    STATE(44);
     SET_LEX_STATE(14);
     REDUCE(ts_sym_times, ts_sym_factor, 1, COLLAPSE({0}))
     REDUCE(ts_builtin_sym_end, ts_sym_factor, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(45, 11);
+    STATE(45);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_expression, 3, COLLAPSE({0, 0, 0}))
     END_STATE();
     
-    STATE(46, 11);
+    STATE(46);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 47)
     SHIFT(ts_sym_factor, 9)
@@ -441,18 +443,18 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 47)
     END_STATE();
     
-    STATE(47, 11);
+    STATE(47);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 48)
     END_STATE();
     
-    STATE(48, 11);
+    STATE(48);
     SET_LEX_STATE(14);
     REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     REDUCE(ts_builtin_sym_end, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(49, 11);
+    STATE(49);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_expression, 50)
     SHIFT(ts_sym_factor, 9)
@@ -463,12 +465,12 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 50)
     END_STATE();
     
-    STATE(50, 11);
+    STATE(50);
     SET_LEX_STATE(3);
     SHIFT(ts_aux_sym_token2, 51)
     END_STATE();
     
-    STATE(51, 11);
+    STATE(51);
     SET_LEX_STATE(13);
     REDUCE(ts_sym_plus, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
     REDUCE(ts_sym_times, ts_sym_factor, 3, COLLAPSE({1, 0, 1}))
diff --git a/examples/parsers/json.c b/examples/parsers/json.c
index 6fc165d5..c6930964 100644
--- a/examples/parsers/json.c
+++ b/examples/parsers/json.c
@@ -1,5 +1,7 @@
 #include "tree_sitter/parser.h"
 
+#define TS_SYMBOL_COUNT 15
+
 enum {
     ts_sym_array,
     ts_sym_number,
@@ -199,7 +201,7 @@ LEX_FN() {
 PARSE_TABLE() {
     START_TABLE(60)
     
-    STATE(0, 15);
+    STATE(0);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_array, 1)
     SHIFT(ts_sym_number, 1)
@@ -210,29 +212,29 @@ PARSE_TABLE() {
     SHIFT(ts_sym_left_bracket, 55)
     END_STATE();
     
-    STATE(1, 15);
+    STATE(1);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_value, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(2, 15);
+    STATE(2);
     SET_LEX_STATE(0);
     ACCEPT_INPUT(ts_builtin_sym_end)
     END_STATE();
     
-    STATE(3, 15);
+    STATE(3);
     SET_LEX_STATE(20);
     SHIFT(ts_sym_string, 4)
     SHIFT(ts_sym_right_brace, 51)
     SHIFT(ts_builtin_sym_error, 52)
     END_STATE();
     
-    STATE(4, 15);
+    STATE(4);
     SET_LEX_STATE(18);
     SHIFT(ts_sym_colon, 5)
     END_STATE();
     
-    STATE(5, 15);
+    STATE(5);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_array, 6)
     SHIFT(ts_sym_number, 6)
@@ -243,31 +245,31 @@ PARSE_TABLE() {
     SHIFT(ts_sym_left_bracket, 19)
     END_STATE();
     
-    STATE(6, 15);
+    STATE(6);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_comma, ts_sym_value, 1, COLLAPSE({0}))
     REDUCE(ts_sym_right_brace, ts_sym_value, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(7, 15);
+    STATE(7);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 49)
     END_STATE();
     
-    STATE(8, 15);
+    STATE(8);
     SET_LEX_STATE(22);
     SHIFT(ts_sym_string, 9)
     SHIFT(ts_builtin_sym_error, 47)
     END_STATE();
     
-    STATE(9, 15);
+    STATE(9);
     SET_LEX_STATE(18);
     SHIFT(ts_sym_colon, 10)
     END_STATE();
     
-    STATE(10, 15);
+    STATE(10);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_array, 6)
     SHIFT(ts_sym_number, 6)
@@ -278,31 +280,31 @@ PARSE_TABLE() {
     SHIFT(ts_sym_left_bracket, 19)
     END_STATE();
     
-    STATE(11, 15);
+    STATE(11);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 12)
     END_STATE();
     
-    STATE(12, 15);
+    STATE(12);
     SET_LEX_STATE(4);
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 5, COLLAPSE({1, 0, 1, 0, 1}))
     END_STATE();
     
-    STATE(13, 15);
+    STATE(13);
     SET_LEX_STATE(20);
     SHIFT(ts_sym_string, 14)
     SHIFT(ts_sym_right_brace, 43)
     SHIFT(ts_builtin_sym_error, 44)
     END_STATE();
     
-    STATE(14, 15);
+    STATE(14);
     SET_LEX_STATE(18);
     SHIFT(ts_sym_colon, 15)
     END_STATE();
     
-    STATE(15, 15);
+    STATE(15);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_array, 6)
     SHIFT(ts_sym_number, 6)
@@ -313,25 +315,25 @@ PARSE_TABLE() {
     SHIFT(ts_sym_left_bracket, 19)
     END_STATE();
     
-    STATE(16, 15);
+    STATE(16);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 17)
     END_STATE();
     
-    STATE(17, 15);
+    STATE(17);
     SET_LEX_STATE(4);
     SHIFT(ts_sym_right_brace, 18)
     END_STATE();
     
-    STATE(18, 15);
+    STATE(18);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_comma, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
     REDUCE(ts_sym_right_brace, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
     END_STATE();
     
-    STATE(19, 15);
+    STATE(19);
     SET_LEX_STATE(21);
     SHIFT(ts_sym_array, 20)
     SHIFT(ts_sym_number, 20)
@@ -344,20 +346,20 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 21)
     END_STATE();
     
-    STATE(20, 15);
+    STATE(20);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_comma, ts_sym_value, 1, COLLAPSE({0}))
     REDUCE(ts_sym_right_bracket, ts_sym_value, 1, COLLAPSE({0}))
     END_STATE();
     
-    STATE(21, 15);
+    STATE(21);
     SET_LEX_STATE(5);
     SHIFT(ts_sym_comma, 22)
     REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper1, 40)
     END_STATE();
     
-    STATE(22, 15);
+    STATE(22);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_array, 20)
     SHIFT(ts_sym_number, 20)
@@ -369,31 +371,31 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 23)
     END_STATE();
     
-    STATE(23, 15);
+    STATE(23);
     SET_LEX_STATE(5);
     SHIFT(ts_sym_comma, 22)
     REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper1, 24)
     END_STATE();
     
-    STATE(24, 15);
+    STATE(24);
     SET_LEX_STATE(7);
     REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(25, 15);
+    STATE(25);
     SET_LEX_STATE(20);
     SHIFT(ts_sym_string, 26)
     SHIFT(ts_sym_right_brace, 31)
     SHIFT(ts_builtin_sym_error, 32)
     END_STATE();
     
-    STATE(26, 15);
+    STATE(26);
     SET_LEX_STATE(18);
     SHIFT(ts_sym_colon, 27)
     END_STATE();
     
-    STATE(27, 15);
+    STATE(27);
     SET_LEX_STATE(8);
     SHIFT(ts_sym_array, 6)
     SHIFT(ts_sym_number, 6)
@@ -404,49 +406,49 @@ PARSE_TABLE() {
     SHIFT(ts_sym_left_bracket, 19)
     END_STATE();
     
-    STATE(28, 15);
+    STATE(28);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 29)
     END_STATE();
     
-    STATE(29, 15);
+    STATE(29);
     SET_LEX_STATE(4);
     SHIFT(ts_sym_right_brace, 30)
     END_STATE();
     
-    STATE(30, 15);
+    STATE(30);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_comma, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
     REDUCE(ts_sym_right_bracket, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
     END_STATE();
     
-    STATE(31, 15);
+    STATE(31);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_comma, ts_sym_object, 2, COLLAPSE({1, 1}))
     REDUCE(ts_sym_right_bracket, ts_sym_object, 2, COLLAPSE({1, 1}))
     END_STATE();
     
-    STATE(32, 15);
+    STATE(32);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 33)
     END_STATE();
     
-    STATE(33, 15);
+    STATE(33);
     SET_LEX_STATE(4);
     SHIFT(ts_sym_right_brace, 34)
     END_STATE();
     
-    STATE(34, 15);
+    STATE(34);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_comma, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
     REDUCE(ts_sym_right_bracket, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
     END_STATE();
     
-    STATE(35, 15);
+    STATE(35);
     SET_LEX_STATE(21);
     SHIFT(ts_sym_array, 20)
     SHIFT(ts_sym_number, 20)
@@ -459,116 +461,116 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 36)
     END_STATE();
     
-    STATE(36, 15);
+    STATE(36);
     SET_LEX_STATE(5);
     SHIFT(ts_sym_comma, 22)
     REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper1, 37)
     END_STATE();
     
-    STATE(37, 15);
+    STATE(37);
     SET_LEX_STATE(7);
     SHIFT(ts_sym_right_bracket, 38)
     END_STATE();
     
-    STATE(38, 15);
+    STATE(38);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_comma, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
     REDUCE(ts_sym_right_bracket, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
     END_STATE();
     
-    STATE(39, 15);
+    STATE(39);
     SET_LEX_STATE(5);
     REDUCE(ts_sym_comma, ts_sym_array, 2, COLLAPSE({1, 1}))
     REDUCE(ts_sym_right_bracket, ts_sym_array, 2, COLLAPSE({1, 1}))
     END_STATE();
     
-    STATE(40, 15);
+    STATE(40);
     SET_LEX_STATE(7);
     SHIFT(ts_sym_right_bracket, 41)
     END_STATE();
     
-    STATE(41, 15);
+    STATE(41);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_comma, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
     REDUCE(ts_sym_right_brace, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
     END_STATE();
     
-    STATE(42, 15);
+    STATE(42);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_comma, ts_sym_array, 2, COLLAPSE({1, 1}))
     REDUCE(ts_sym_right_brace, ts_sym_array, 2, COLLAPSE({1, 1}))
     END_STATE();
     
-    STATE(43, 15);
+    STATE(43);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_comma, ts_sym_object, 2, COLLAPSE({1, 1}))
     REDUCE(ts_sym_right_brace, ts_sym_object, 2, COLLAPSE({1, 1}))
     END_STATE();
     
-    STATE(44, 15);
+    STATE(44);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 45)
     END_STATE();
     
-    STATE(45, 15);
+    STATE(45);
     SET_LEX_STATE(4);
     SHIFT(ts_sym_right_brace, 46)
     END_STATE();
     
-    STATE(46, 15);
+    STATE(46);
     SET_LEX_STATE(1);
     REDUCE(ts_sym_comma, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
     REDUCE(ts_sym_right_brace, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
     END_STATE();
     
-    STATE(47, 15);
+    STATE(47);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 48)
     END_STATE();
     
-    STATE(48, 15);
+    STATE(48);
     SET_LEX_STATE(4);
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 3, COLLAPSE({1, 0, 1}))
     END_STATE();
     
-    STATE(49, 15);
+    STATE(49);
     SET_LEX_STATE(4);
     SHIFT(ts_sym_right_brace, 50)
     END_STATE();
     
-    STATE(50, 15);
+    STATE(50);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_object, 6, COLLAPSE({1, 0, 1, 0, 1, 1}))
     END_STATE();
     
-    STATE(51, 15);
+    STATE(51);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_object, 2, COLLAPSE({1, 1}))
     END_STATE();
     
-    STATE(52, 15);
+    STATE(52);
     SET_LEX_STATE(1);
     SHIFT(ts_sym_comma, 8)
     REDUCE(ts_sym_right_brace, ts_aux_sym_repeat_helper2, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper2, 53)
     END_STATE();
     
-    STATE(53, 15);
+    STATE(53);
     SET_LEX_STATE(4);
     SHIFT(ts_sym_right_brace, 54)
     END_STATE();
     
-    STATE(54, 15);
+    STATE(54);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_object, 4, COLLAPSE({1, 0, 1, 1}))
     END_STATE();
     
-    STATE(55, 15);
+    STATE(55);
     SET_LEX_STATE(21);
     SHIFT(ts_sym_array, 20)
     SHIFT(ts_sym_number, 20)
@@ -581,24 +583,24 @@ PARSE_TABLE() {
     SHIFT(ts_builtin_sym_error, 56)
     END_STATE();
     
-    STATE(56, 15);
+    STATE(56);
     SET_LEX_STATE(5);
     SHIFT(ts_sym_comma, 22)
     REDUCE(ts_sym_right_bracket, ts_aux_sym_repeat_helper1, 0, COLLAPSE({}))
     SHIFT(ts_aux_sym_repeat_helper1, 57)
     END_STATE();
     
-    STATE(57, 15);
+    STATE(57);
     SET_LEX_STATE(7);
     SHIFT(ts_sym_right_bracket, 58)
     END_STATE();
     
-    STATE(58, 15);
+    STATE(58);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_array, 4, COLLAPSE({1, 0, 1, 1}))
     END_STATE();
     
-    STATE(59, 15);
+    STATE(59);
     SET_LEX_STATE(0);
     REDUCE(ts_builtin_sym_end, ts_sym_array, 2, COLLAPSE({1, 1}))
     END_STATE();
diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h
index 753e0c75..7a6dae43 100644
--- a/include/tree_sitter/parser.h
+++ b/include/tree_sitter/parser.h
@@ -38,6 +38,7 @@ static const ts_parse_action ** ts_parse_actions; \
 static void ts_init_parse_table()
 
 #define START_TABLE(num_states) \
+ts_symbol_count = TS_SYMBOL_COUNT; \
 static int done = 0; \
 if (!done) { \
     static const ts_parse_action *parse_actions[num_states]; \
@@ -50,11 +51,11 @@ if (!done) { \
 #define END_TABLE() }
 #define END_STATE() }
 
-#define STATE(state_val, num_symbols) \
+#define STATE(state_val) \
 state = state_val; \
 if (1) { \
-    ts_symbol_count = num_symbols; \
-    static ts_parse_action actions_for_state[num_symbols]; \
+    static ts_parse_action actions_for_state_array[TS_SYMBOL_COUNT + 2]; \
+    ts_parse_action *actions_for_state = actions_for_state_array + 2; \
     parse_actions[state] = actions_for_state;
 
 #define SET_LEX_STATE(lex_state_val) \
@@ -80,29 +81,24 @@ ts_parser constructor_name() { \
 }
 
 #define SHIFT(on_symbol, to_state_value) \
-actions_for_state[on_symbol].type = ts_parse_action_type_shift; \
-actions_for_state[on_symbol].data.to_state = to_state_value;
+actions_for_state[on_symbol] = (ts_parse_action) { \
+    .type = ts_parse_action_type_shift, \
+    .data = { .to_state = to_state_value } \
+};
 
 #define REDUCE(on_symbol, symbol_val, child_count_val, collapse_flags_val) \
 do { \
     static const int collapse_flags[child_count_val] = collapse_flags_val; \
-    actions_for_state[on_symbol].type = ts_parse_action_type_reduce; \
-    actions_for_state[on_symbol].data.symbol = symbol_val; \
-    actions_for_state[on_symbol].data.child_count = child_count_val; \
-    actions_for_state[on_symbol].data.collapse_flags = collapse_flags; \
+    actions_for_state[on_symbol] = (ts_parse_action) { \
+        .type = ts_parse_action_type_reduce, \
+        .data = { .symbol = symbol_val, .child_count = child_count_val, .collapse_flags = collapse_flags } \
+    }; \
 } while(0);
 
 #define ACCEPT_INPUT(on_symbol) \
-actions_for_state[on_symbol].type = ts_parse_action_type_accept; \
-
-#define PARSE_ERROR(count, inputs) \
-{ \
-    static const ts_symbol expected_inputs[] = inputs; \
-    if (ts_lr_parser_handle_error(parser, count, expected_inputs)) \
-        goto next_state; \
-    else \
-        goto done; \
-}
+actions_for_state[on_symbol] = (ts_parse_action) { \
+    .type = ts_parse_action_type_accept, \
+};
 
 #define START_LEXER() \
 ts_lexer_skip_whitespace(lexer); \
diff --git a/src/compiler/generate_code/c_code.cc b/src/compiler/generate_code/c_code.cc
index a3e8b069..ffa33e8d 100644
--- a/src/compiler/generate_code/c_code.cc
+++ b/src/compiler/generate_code/c_code.cc
@@ -189,6 +189,10 @@ namespace tree_sitter {
                 body += _default("LEX_PANIC();");
                 return _switch("LEX_STATE()", body);
             }
+            
+            string symbol_count() {
+                return "#define TS_SYMBOL_COUNT " + to_string(parse_table.symbols.size());
+            }
 
             string symbol_enum() {
                 string result = "enum {\n";
@@ -274,7 +278,7 @@ namespace tree_sitter {
                         "START_TABLE(" + to_string(parse_table.states.size()) + ")",
                         join(map_to_string<ParseState>(parse_table.states, [&](ParseState state) -> string {
                             return join({
-                                "STATE(" + to_string(state_id++) + ", " + to_string(parse_table.symbols.size()) + ");",
+                                "STATE(" + to_string(state_id++) + ");",
                                 parse_table_row_for_state(state),
                                 "END_STATE();"
                             });
@@ -292,10 +296,9 @@ namespace tree_sitter {
             string code() {
                 return join({
                     includes(),
+                    symbol_count(),
                     symbol_enum(),
                     rule_names_list(),
-//                    recover_function(),
-//                    parse_function(),
                     lex_function(),
                     parse_table_function(),
                     parser_export(),
diff --git a/src/runtime/tree.c b/src/runtime/tree.c
index c73f6144..48f35449 100644
--- a/src/runtime/tree.c
+++ b/src/runtime/tree.c
@@ -79,10 +79,10 @@ size_t ts_tree_child_count(const ts_tree *tree) {
     return tree->data.children.count;
 }
 
-static const char *NULL_TREE_STRING = "(NULL)";
-static const char *ERROR_TREE_STRING = "(ERROR)";
-
 static size_t tree_write_to_string(const ts_tree *tree, const char **symbol_names, char *string, size_t limit) {
+    static const char *NULL_TREE_STRING = "(NULL)";
+    static const char *ERROR_TREE_STRING = "(ERROR)";
+    
     if (!tree)
         return snprintf(string, limit, "%s", NULL_TREE_STRING);
     if (tree->symbol == ts_builtin_sym_error)