diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c
index 7d558182..32e4e567 100644
--- a/spec/fixtures/parsers/arithmetic.c
+++ b/spec/fixtures/parsers/arithmetic.c
@@ -2,28 +2,28 @@
 #include <ctype.h>
 
 enum ts_symbol {
-    ts_aux_token1,
     ts_symbol_plus,
-    ts_aux_token2,
     ts_symbol_number,
+    ts_symbol_variable,
     ts_symbol_factor,
     ts_symbol_times,
+    ts_aux_token1,
     ts_symbol_term,
-    ts_symbol_variable,
     ts_symbol_expression,
+    ts_aux_token2,
     ts_symbol___END__,
 };
 
 static const char *ts_symbol_names[] = {
-    "token1",
     "plus",
-    "token2",
     "number",
+    "variable",
     "factor",
     "times",
+    "token1",
     "term",
-    "variable",
     "expression",
+    "token2",
     "__END__",
 };
 
@@ -73,14 +73,14 @@ static void ts_lex(TSParser *parser) {
                 ADVANCE(8);
             LEX_ERROR(2, EXPECT({"')'", "'+'"}));
         case 10:
-            if (('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z') ||
-                ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z'))
-                ADVANCE(13);
             if ((LOOKAHEAD_CHAR() == '('))
                 ADVANCE(12);
+            if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
+                ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
+                ADVANCE(13);
             if ((isdigit(LOOKAHEAD_CHAR())))
                 ADVANCE(11);
-            LEX_ERROR(4, EXPECT({"'A'-'Z'", "'a'-'z'", "'('", "<digit>"}));
+            LEX_ERROR(4, EXPECT({"'A'-'Z'", "'('", "'a'-'z'", "<digit>"}));
         case 11:
             if ((isdigit(LOOKAHEAD_CHAR())))
                 ADVANCE(11);
@@ -88,8 +88,8 @@ static void ts_lex(TSParser *parser) {
         case 12:
             ACCEPT_TOKEN(ts_aux_token1);
         case 13:
-            if (('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z') ||
-                ('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z'))
+            if (('A' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'Z') ||
+                ('a' <= LOOKAHEAD_CHAR() && LOOKAHEAD_CHAR() <= 'z'))
                 ADVANCE(13);
             ACCEPT_TOKEN(ts_symbol_variable);
         case 14:
@@ -99,13 +99,13 @@ static void ts_lex(TSParser *parser) {
                 ADVANCE(1);
             LEX_ERROR(2, EXPECT({"'+'", "<EOF>"}));
         case 15:
-            if ((LOOKAHEAD_CHAR() == '+'))
-                ADVANCE(8);
             if ((LOOKAHEAD_CHAR() == '*'))
                 ADVANCE(3);
+            if ((LOOKAHEAD_CHAR() == '+'))
+                ADVANCE(8);
             if ((LOOKAHEAD_CHAR() == '\0'))
                 ADVANCE(1);
-            LEX_ERROR(3, EXPECT({"'+'", "'*'", "<EOF>"}));
+            LEX_ERROR(3, EXPECT({"'*'", "'+'", "<EOF>"}));
         default:
             LEX_PANIC();
     }
@@ -118,20 +118,20 @@ static TSParseResult ts_parse(const char *input) {
         case 0:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(42);
-                case ts_symbol_number:
-                    SHIFT(41);
                 case ts_symbol_factor:
                     SHIFT(45);
                 case ts_symbol_term:
                     SHIFT(2);
+                case ts_aux_token1:
+                    SHIFT(42);
+                case ts_symbol_number:
+                    SHIFT(41);
                 case ts_symbol_variable:
                     SHIFT(41);
                 case ts_symbol_expression:
                     SHIFT(1);
                 default:
-                    PARSE_ERROR(6, EXPECT({"factor", "term", "expression", "variable", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 1:
             SET_LEX_STATE(0);
@@ -154,18 +154,18 @@ static TSParseResult ts_parse(const char *input) {
         case 3:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
+                case ts_symbol_factor:
+                    SHIFT(34);
                 case ts_aux_token1:
                     SHIFT(6);
                 case ts_symbol_number:
                     SHIFT(5);
-                case ts_symbol_factor:
-                    SHIFT(34);
                 case ts_symbol_variable:
                     SHIFT(5);
                 case ts_symbol_term:
                     SHIFT(4);
                 default:
-                    PARSE_ERROR(5, EXPECT({"term", "variable", "factor", "number", "token1"}));
+                    PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"}));
             }
         case 4:
             SET_LEX_STATE(0);
@@ -188,20 +188,20 @@ static TSParseResult ts_parse(const char *input) {
         case 6:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(32);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(32);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 7:
             SET_LEX_STATE(9);
@@ -216,18 +216,18 @@ static TSParseResult ts_parse(const char *input) {
         case 8:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
+                case ts_symbol_factor:
+                    SHIFT(25);
                 case ts_aux_token1:
                     SHIFT(11);
                 case ts_symbol_number:
                     SHIFT(10);
-                case ts_symbol_factor:
-                    SHIFT(25);
                 case ts_symbol_variable:
                     SHIFT(10);
                 case ts_symbol_term:
                     SHIFT(9);
                 default:
-                    PARSE_ERROR(5, EXPECT({"term", "variable", "factor", "number", "token1"}));
+                    PARSE_ERROR(5, EXPECT({"term", "variable", "number", "token1", "factor"}));
             }
         case 9:
             SET_LEX_STATE(4);
@@ -250,20 +250,20 @@ static TSParseResult ts_parse(const char *input) {
         case 11:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(23);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(23);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 12:
             SET_LEX_STATE(7);
@@ -280,20 +280,20 @@ static TSParseResult ts_parse(const char *input) {
         case 13:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(14);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(14);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 14:
             SET_LEX_STATE(4);
@@ -330,16 +330,16 @@ static TSParseResult ts_parse(const char *input) {
         case 17:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
+                case ts_symbol_factor:
+                    SHIFT(22);
                 case ts_aux_token1:
                     SHIFT(19);
                 case ts_symbol_number:
                     SHIFT(18);
-                case ts_symbol_factor:
-                    SHIFT(22);
                 case ts_symbol_variable:
                     SHIFT(18);
                 default:
-                    PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
+                    PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
             }
         case 18:
             SET_LEX_STATE(9);
@@ -354,20 +354,20 @@ static TSParseResult ts_parse(const char *input) {
         case 19:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(20);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(20);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 20:
             SET_LEX_STATE(4);
@@ -428,16 +428,16 @@ static TSParseResult ts_parse(const char *input) {
         case 26:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
+                case ts_symbol_factor:
+                    SHIFT(31);
                 case ts_aux_token1:
                     SHIFT(28);
                 case ts_symbol_number:
                     SHIFT(27);
-                case ts_symbol_factor:
-                    SHIFT(31);
                 case ts_symbol_variable:
                     SHIFT(27);
                 default:
-                    PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
+                    PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
             }
         case 27:
             SET_LEX_STATE(4);
@@ -450,20 +450,20 @@ static TSParseResult ts_parse(const char *input) {
         case 28:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(29);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(29);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 29:
             SET_LEX_STATE(4);
@@ -520,16 +520,16 @@ static TSParseResult ts_parse(const char *input) {
         case 35:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
+                case ts_symbol_factor:
+                    SHIFT(40);
                 case ts_aux_token1:
                     SHIFT(37);
                 case ts_symbol_number:
                     SHIFT(36);
-                case ts_symbol_factor:
-                    SHIFT(40);
                 case ts_symbol_variable:
                     SHIFT(36);
                 default:
-                    PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
+                    PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
             }
         case 36:
             SET_LEX_STATE(0);
@@ -542,20 +542,20 @@ static TSParseResult ts_parse(const char *input) {
         case 37:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(38);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(38);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 38:
             SET_LEX_STATE(4);
@@ -596,20 +596,20 @@ static TSParseResult ts_parse(const char *input) {
         case 42:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(43);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(43);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 43:
             SET_LEX_STATE(4);
@@ -634,28 +634,28 @@ static TSParseResult ts_parse(const char *input) {
         case 45:
             SET_LEX_STATE(15);
             switch (LOOKAHEAD_SYM()) {
-                case ts_symbol_plus:
-                    REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
                 case ts_symbol___END__:
                     REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
+                case ts_symbol_plus:
+                    REDUCE(ts_symbol_term, 1, COLLAPSE({0}));
                 case ts_symbol_times:
                     SHIFT(46);
                 default:
-                    PARSE_ERROR(3, EXPECT({"times", "__END__", "plus"}));
+                    PARSE_ERROR(3, EXPECT({"times", "plus", "__END__"}));
             }
         case 46:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
+                case ts_symbol_factor:
+                    SHIFT(51);
                 case ts_aux_token1:
                     SHIFT(48);
                 case ts_symbol_number:
                     SHIFT(47);
-                case ts_symbol_factor:
-                    SHIFT(51);
                 case ts_symbol_variable:
                     SHIFT(47);
                 default:
-                    PARSE_ERROR(4, EXPECT({"variable", "factor", "number", "token1"}));
+                    PARSE_ERROR(4, EXPECT({"variable", "number", "token1", "factor"}));
             }
         case 47:
             SET_LEX_STATE(14);
@@ -670,20 +670,20 @@ static TSParseResult ts_parse(const char *input) {
         case 48:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
-                case ts_aux_token1:
-                    SHIFT(13);
-                case ts_symbol_number:
-                    SHIFT(12);
-                case ts_symbol_expression:
-                    SHIFT(49);
-                case ts_symbol_variable:
-                    SHIFT(12);
                 case ts_symbol_factor:
                     SHIFT(16);
                 case ts_symbol_term:
                     SHIFT(7);
+                case ts_aux_token1:
+                    SHIFT(13);
+                case ts_symbol_number:
+                    SHIFT(12);
+                case ts_symbol_variable:
+                    SHIFT(12);
+                case ts_symbol_expression:
+                    SHIFT(49);
                 default:
-                    PARSE_ERROR(6, EXPECT({"term", "factor", "variable", "expression", "number", "token1"}));
+                    PARSE_ERROR(6, EXPECT({"expression", "variable", "number", "token1", "term", "factor"}));
             }
         case 49:
             SET_LEX_STATE(4);
diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c
index 681dfa48..bc358c60 100644
--- a/spec/fixtures/parsers/json.c
+++ b/spec/fixtures/parsers/json.c
@@ -2,39 +2,39 @@
 #include <ctype.h>
 
 enum ts_symbol {
-    ts_aux_token6,
-    ts_symbol_number,
+    ts_symbol_string,
     ts_symbol_array,
-    ts_symbol___END__,
+    ts_aux_token3,
     ts_symbol_object,
     ts_aux_repeat_helper1,
+    ts_aux_token6,
+    ts_symbol_number,
     ts_aux_token7,
     ts_aux_token5,
-    ts_symbol_string,
     ts_aux_token4,
-    ts_aux_token1,
-    ts_aux_token3,
+    ts_symbol___END__,
+    ts_aux_token2,
     ts_aux_repeat_helper2,
     ts_symbol_value,
-    ts_aux_token2,
+    ts_aux_token1,
 };
 
 static const char *ts_symbol_names[] = {
-    "token6",
-    "number",
+    "string",
     "array",
-    "__END__",
+    "token3",
     "object",
     "repeat_helper1",
+    "token6",
+    "number",
     "token7",
     "token5",
-    "string",
     "token4",
-    "token1",
-    "token3",
+    "__END__",
+    "token2",
     "repeat_helper2",
     "value",
-    "token2",
+    "token1",
 };
 
 static void ts_lex(TSParser *parser) {
@@ -130,20 +130,20 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(53);
-                case ts_aux_token5:
-                    SHIFT(47);
-                case ts_symbol_array:
-                    SHIFT(53);
                 case ts_symbol_string:
                     SHIFT(53);
+                case ts_symbol_array:
+                    SHIFT(53);
                 case ts_symbol_object:
                     SHIFT(53);
+                case ts_aux_token5:
+                    SHIFT(47);
                 case ts_aux_token1:
                     SHIFT(2);
                 case ts_symbol_value:
                     SHIFT(1);
                 default:
-                    PARSE_ERROR(7, EXPECT({"value", "token1", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"value", "token1", "array", "string", "token5", "object", "number"}));
             }
         case 1:
             SET_LEX_STATE(0);
@@ -158,40 +158,40 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(44);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 3:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(4);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 4:
             SET_LEX_STATE(2);
@@ -228,40 +228,40 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(43);
-                case ts_aux_token5:
-                    SHIFT(35);
-                case ts_symbol_array:
-                    SHIFT(43);
                 case ts_symbol_string:
                     SHIFT(43);
+                case ts_aux_token5:
+                    SHIFT(35);
                 case ts_symbol_object:
                     SHIFT(43);
+                case ts_symbol_array:
+                    SHIFT(43);
                 case ts_symbol_value:
                     SHIFT(41);
                 case ts_aux_token1:
                     SHIFT(8);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 8:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(9);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 9:
             SET_LEX_STATE(2);
@@ -314,20 +314,20 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(15);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 15:
             SET_LEX_STATE(2);
@@ -380,40 +380,40 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(34);
-                case ts_aux_token5:
-                    SHIFT(26);
-                case ts_symbol_array:
-                    SHIFT(34);
                 case ts_symbol_string:
                     SHIFT(34);
+                case ts_aux_token5:
+                    SHIFT(26);
                 case ts_symbol_object:
                     SHIFT(34);
+                case ts_symbol_array:
+                    SHIFT(34);
                 case ts_symbol_value:
                     SHIFT(32);
                 case ts_aux_token1:
                     SHIFT(21);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 21:
             SET_LEX_STATE(10);
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(22);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 22:
             SET_LEX_STATE(2);
@@ -476,20 +476,20 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(29);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 29:
             SET_LEX_STATE(2);
@@ -572,20 +572,20 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(38);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 38:
             SET_LEX_STATE(2);
@@ -696,20 +696,20 @@ static TSParseResult ts_parse(const char *input) {
             switch (LOOKAHEAD_SYM()) {
                 case ts_symbol_number:
                     SHIFT(25);
-                case ts_aux_token5:
-                    SHIFT(12);
-                case ts_symbol_array:
-                    SHIFT(25);
                 case ts_symbol_string:
                     SHIFT(25);
+                case ts_aux_token5:
+                    SHIFT(12);
                 case ts_symbol_object:
                     SHIFT(25);
+                case ts_symbol_array:
+                    SHIFT(25);
                 case ts_symbol_value:
                     SHIFT(50);
                 case ts_aux_token1:
                     SHIFT(3);
                 default:
-                    PARSE_ERROR(7, EXPECT({"token1", "value", "string", "object", "array", "token5", "number"}));
+                    PARSE_ERROR(7, EXPECT({"token1", "value", "array", "string", "object", "token5", "number"}));
             }
         case 50:
             SET_LEX_STATE(2);
diff --git a/src/compiler/build_tables/item_set_transitions.cpp b/src/compiler/build_tables/item_set_transitions.cpp
index dc6759f8..ed26c382 100644
--- a/src/compiler/build_tables/item_set_transitions.cpp
+++ b/src/compiler/build_tables/item_set_transitions.cpp
@@ -27,7 +27,7 @@ namespace tree_sitter {
                         item_transitions.add(rule, make_shared<LexItemSet>(new_item_set));
                     }
                 }
-                
+
                 result.merge(item_transitions, [](shared_ptr<const LexItemSet> left, shared_ptr<const LexItemSet> right) -> shared_ptr<const LexItemSet> {
                     return make_shared<LexItemSet>(merge_sets(*left, *right));
                 });
diff --git a/src/compiler/lex_table.cpp b/src/compiler/lex_table.cpp
index c7e7c8e8..210e6642 100644
--- a/src/compiler/lex_table.cpp
+++ b/src/compiler/lex_table.cpp
@@ -4,7 +4,6 @@ using std::string;
 using std::to_string;
 using std::unordered_map;
 using std::unordered_set;
-using std::vector;
 using tree_sitter::rules::Symbol;
 
 namespace tree_sitter {
diff --git a/src/compiler/rules/character.cpp b/src/compiler/rules/character.cpp
index 3d4fd643..f45996c2 100644
--- a/src/compiler/rules/character.cpp
+++ b/src/compiler/rules/character.cpp
@@ -12,10 +12,6 @@ namespace tree_sitter  {
             value.range.max_character = bounds.second;
         }
         
-        Character::Character(char character) : matches({ CharacterMatch(character) }), sign(true) {}
-        Character::Character(CharacterClass char_class) : matches({ CharacterMatch(char_class) }), sign(true) {}
-        Character::Character(const std::vector<CharacterMatch> &matches, bool sign) : matches(matches), sign(sign) {}
-        
         bool CharacterMatch::operator==(const CharacterMatch &right) const {
             if (type != right.type)
                 return false;
@@ -50,6 +46,10 @@ namespace tree_sitter  {
             }
         }
         
+        Character::Character(char character) : matches({ CharacterMatch(character) }), sign(true) {}
+        Character::Character(CharacterClass char_class) : matches({ CharacterMatch(char_class) }), sign(true) {}
+        Character::Character(const std::unordered_set<CharacterMatch> &matches, bool sign) : matches(matches), sign(sign) {}
+        
         bool Character::operator==(const Rule &rule) const {
             const Character *other = dynamic_cast<const Character *>(&rule);
             return other && this->operator==(*other);
@@ -57,10 +57,7 @@ namespace tree_sitter  {
         
         bool Character::operator==(const Character &other) const {
             if (other.sign != sign) return false;
-            auto size = matches.size();
-            if (other.matches.size() != size) return false;
-            for (int i = 0; i < size; i++)
-                if (!(matches[i] == other.matches[i])) return false;
+            if (other.matches != matches) return false;
             return true;
         }
 
diff --git a/src/compiler/rules/character.h b/src/compiler/rules/character.h
index afe9965d..83edcc4f 100644
--- a/src/compiler/rules/character.h
+++ b/src/compiler/rules/character.h
@@ -1,8 +1,7 @@
-#ifndef __tree_sitter__char__
-#define __tree_sitter__char__
+#ifndef __tree_sitter__character__
+#define __tree_sitter__character__
 
 #include "rule.h"
-#include <vector>
 #include <unordered_set>
 
 namespace tree_sitter  {
@@ -35,24 +34,6 @@ namespace tree_sitter  {
             bool operator==(const CharacterMatch &) const;
             std::string to_string() const;
         };
-
-        class Character : public Rule {
-        public:
-            Character(char character);
-            Character(CharacterClass character_class);
-            Character(char min_character, char max_character);
-            Character(const std::vector<CharacterMatch> &matches, bool sign);
-            
-            bool operator==(const Rule& other) const;
-            bool operator==(const Character& other) const;
-            size_t hash_code() const;
-            rule_ptr copy() const;
-            std::string to_string() const;
-            void accept(Visitor &visitor) const;
-
-            std::vector<CharacterMatch> matches;
-            bool sign;
-        };
     }
 }
 
@@ -76,6 +57,29 @@ namespace std {
     };
 }
 
+namespace tree_sitter  {
+    namespace rules {
+
+        class Character : public Rule {
+        public:
+            Character(char character);
+            Character(CharacterClass character_class);
+            Character(char min_character, char max_character);
+            Character(const std::unordered_set<CharacterMatch> &matches, bool sign);
+            
+            bool operator==(const Rule& other) const;
+            bool operator==(const Character& other) const;
+            size_t hash_code() const;
+            rule_ptr copy() const;
+            std::string to_string() const;
+            void accept(Visitor &visitor) const;
+
+            std::unordered_set<CharacterMatch> matches;
+            bool sign;
+        };
+    }
+}
+
 namespace std {
     template<>
     struct hash<tree_sitter::rules::Character> : hash<tree_sitter::rules::Rule> {};
diff --git a/src/compiler/rules/pattern.cpp b/src/compiler/rules/pattern.cpp
index 74587eee..ec0f7162 100644
--- a/src/compiler/rules/pattern.cpp
+++ b/src/compiler/rules/pattern.cpp
@@ -44,9 +44,9 @@ namespace tree_sitter {
                     next();
                     is_affirmative = false;
                 }
-                std::vector<CharacterMatch> matches;
+                std::unordered_set<CharacterMatch> matches;
                 while (has_more_input() && (peek() != ']'))
-                    matches.push_back(single_char());
+                    matches.insert(single_char());
                 return character(matches, is_affirmative);
             }
             
diff --git a/src/compiler/rules/rules.cpp b/src/compiler/rules/rules.cpp
index 2e74670e..603bfb86 100644
--- a/src/compiler/rules/rules.cpp
+++ b/src/compiler/rules/rules.cpp
@@ -18,7 +18,7 @@ namespace tree_sitter {
             return make_shared<Character>(value);
         }
         
-        rule_ptr character(const std::vector<CharacterMatch> &matches, bool is_affirmative) {
+        rule_ptr character(const std::unordered_set<CharacterMatch> &matches, bool is_affirmative) {
             return make_shared<Character>(matches, is_affirmative);
         }
 
diff --git a/src/compiler/rules/rules.h b/src/compiler/rules/rules.h
index 2b7cace2..d3080645 100644
--- a/src/compiler/rules/rules.h
+++ b/src/compiler/rules/rules.h
@@ -17,8 +17,8 @@ namespace tree_sitter {
         rule_ptr blank();
         rule_ptr character(char value);
         rule_ptr character(CharacterClass value);
-        rule_ptr character(const std::vector<CharacterMatch> &matches);
-        rule_ptr character(const std::vector<CharacterMatch> &matches, bool);
+        rule_ptr character(const std::unordered_set<CharacterMatch> &matches);
+        rule_ptr character(const std::unordered_set<CharacterMatch> &matches, bool);
         
         rule_ptr choice(const std::initializer_list<rule_ptr> &rules);
         rule_ptr pattern(const std::string &value);