rlmeta2

New experiment with rlmeta.

Home

Source code

git clone https://projects.rickardlindberg.me/scm/rlmeta2.git

Recent events

2025-11-01 12:36 Rickard pushed to rlmeta2

commit 4bc44789080191fabc74e1230518afec30ed4da0
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 12:29:46 2025 +0100

    Remove ignored file which is no longer generated

diff --git a/08_translate_to_c/.gitignore b/08_translate_to_c/.gitignore
index c1cc0ac..ac9852b 100644
--- a/08_translate_to_c/.gitignore
+++ b/08_translate_to_c/.gitignore
@@ -1,6 +1,5 @@
 rlmeta2
 rlmeta2_meta.c
-rlmeta2_meta
 
 table
 table.c

commit 9eab4771e7a36b7e7e5b6963ae1ae48e8153c519
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 12:27:11 2025 +0100

    Get rid of debug printouts

diff --git a/08_translate_to_c/rlmeta2.c b/08_translate_to_c/rlmeta2.c
index 665f354..2bf5df1 100644
--- a/08_translate_to_c/rlmeta2.c
+++ b/08_translate_to_c/rlmeta2.c
@@ -100,7 +100,6 @@ struct ParseState* create_parse_state_from_stdin() {
         parse_state->input_buffer->size++;
     }
     parse_state->input_buffer->size--;
-    fprintf(stderr, "debug: stdin data memory = %p\n", parse_state->input_buffer->buffer);
     return parse_state;
 }
 
@@ -136,7 +135,6 @@ struct Action* create_action(void (*function)(struct Runtime*, struct Variables*
     action->start = start;
     action->end = end;
     action->len = end-start;
-    fprintf(stderr, "debug: action [start=%d] [end=%d]\n", action->start, action->end);
     return action;
 }
 
@@ -156,14 +154,6 @@ void append_data(struct Chunks* chunks, struct Buffer* data, int indentation_del
     chunk->indentation_delta = indentation_delta;
     chunks->last->next = chunk;
     chunks->last = chunk;
-    fprintf(stderr, "debug: append chunk = %p\n", chunk);
-    if (chunk->data) {
-        fprintf(stderr, "  data = ");
-        for (int i=0; i<chunk->data->size; i++) {
-            fprintf(stderr, "%c", chunk->data->buffer[i]);
-        }
-        fprintf(stderr, "\n");
-    }
 }
 
 struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {
@@ -194,14 +184,12 @@ void run_action(struct Action* action, struct Runtime* runtime) {
         action->function(runtime, action->variables);
     } else {
         if (action->variables) {
-            fprintf(stderr, "debug_run_action variables\n");
             struct Variable* variable = action->variables->pre_first->next;
             while (variable) {
                 run_action(variable->action, runtime);
                 variable = variable->next;
             }
         } else {
-            fprintf(stderr, "debug_run_action else\n");
             append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);
         }
     }
@@ -242,7 +230,6 @@ struct Action* lookup_action(struct Variables* variables, struct Buffer* name_to
     struct Variable* variable = variables->pre_first->next;
     while (variable) {
         if (compare_buffers(variable->name, name_to_look_for)) {
-            fprintf(stderr, "debug: found action %p\n", variable->action);
             return variable->action;
         } else {
             variable = variable->next;
@@ -270,14 +257,11 @@ unsigned int max(unsigned int a, unsigned int b) {
 }
 
 void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {
-    fprintf(stderr, "debug: render chunks\n");
     if (chunks) {
         struct Chunk* chunk = chunks->pre_first->next;
         while (chunk) {
             *indent += chunk->indentation_delta;
             if (chunk->data) {
-                fprintf(stderr, "debug: chunk data memory = %p\n", chunk->data->buffer);
-                fprintf(stderr, "debug: arena offset      = %u\n", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));
                 for (int i=0; i<chunk->data->size; i++) {
                     if (*last_char == '\n') {
                         for (int j=0; j<*indent; j++) {
@@ -391,585 +375,556 @@ static char symbol_93[] = "pos = allocate(1);\n";
 static char symbol_94[] = "parse_state->input_buffer->size++;\n";
 static char symbol_95[] = "}\n";
 static char symbol_96[] = "parse_state->input_buffer->size--;\n";
-static char symbol_97[] = "fprintf(stderr, \"debug: stdin data memory = %p\\n\", parse_state->input_buffer->buffer);\n";
-static char symbol_98[] = "return parse_state;\n";
-static char symbol_99[] = "}\n";
-static char symbol_100[] = "\n";
-static char symbol_101[] = "struct Chunks* create_chunks() {\n";
-static char symbol_102[] = "struct Chunks* chunks = allocate(sizeof(struct Chunks));\n";
-static char symbol_103[] = "chunks->pre_first = allocate(sizeof(struct Chunk));\n";
-static char symbol_104[] = "chunks->pre_first->next = NULL;\n";
-static char symbol_105[] = "chunks->last = chunks->pre_first;\n";
-static char symbol_106[] = "return chunks;\n";
-static char symbol_107[] = "}\n";
-static char symbol_108[] = "\n";
-static char symbol_109[] = "struct Placeholders* create_placeholders() {\n";
-static char symbol_110[] = "struct Placeholders* placeholders = allocate(sizeof(struct Placeholders));\n";
-static char symbol_111[] = "placeholders->pre_first = allocate(sizeof(struct Placeholder));\n";
-static char symbol_112[] = "placeholders->pre_first->next = NULL;\n";
-static char symbol_113[] = "placeholders->last = placeholders->pre_first;\n";
-static char symbol_114[] = "return placeholders;\n";
-static char symbol_115[] = "}\n";
-static char symbol_116[] = "\n";
-static char symbol_117[] = "struct Runtime* create_runtime() {\n";
-static char symbol_118[] = "struct Runtime* runtime = allocate(sizeof(struct Runtime));\n";
-static char symbol_119[] = "runtime->main_chunks = create_chunks();\n";
-static char symbol_120[] = "runtime->current_chunks = runtime->main_chunks;\n";
-static char symbol_121[] = "runtime->placeholders = create_placeholders();\n";
-static char symbol_122[] = "return runtime;\n";
-static char symbol_123[] = "}\n";
-static char symbol_124[] = "\n";
-static char symbol_125[] = "struct Action* create_action(void (*function)(struct Runtime*, struct Variables*), struct Variables* variables, struct Buffer* input_buffer, unsigned int start, unsigned int end) {\n";
-static char symbol_126[] = "struct Action* action = allocate(sizeof(struct Action));\n";
-static char symbol_127[] = "action->function = function;\n";
-static char symbol_128[] = "action->variables = variables;\n";
-static char symbol_129[] = "action->input_buffer = input_buffer;\n";
-static char symbol_130[] = "action->start = start;\n";
-static char symbol_131[] = "action->end = end;\n";
-static char symbol_132[] = "action->len = end-start;\n";
-static char symbol_133[] = "fprintf(stderr, \"debug: action [start=%d] [end=%d]\\n\", action->start, action->end);\n";
-static char symbol_134[] = "return action;\n";
-static char symbol_135[] = "}\n";
-static char symbol_136[] = "\n";
-static char symbol_137[] = "struct Variables* create_variables() {\n";
-static char symbol_138[] = "struct Variables* variables = allocate(sizeof(struct Variables));\n";
-static char symbol_139[] = "variables->pre_first = allocate(sizeof(struct Variable));\n";
-static char symbol_140[] = "variables->pre_first->next = NULL;\n";
-static char symbol_141[] = "variables->last = variables->pre_first;\n";
-static char symbol_142[] = "return variables;\n";
-static char symbol_143[] = "}\n";
-static char symbol_144[] = "\n";
-static char symbol_145[] = "void append_data(struct Chunks* chunks, struct Buffer* data, int indentation_delta, struct Chunks* sub_chunks) {\n";
-static char symbol_146[] = "struct Chunk* chunk = allocate(sizeof(struct Chunk));\n";
-static char symbol_147[] = "chunk->next = NULL;\n";
-static char symbol_148[] = "chunk->data = data;\n";
-static char symbol_149[] = "chunk->chunks = sub_chunks;\n";
-static char symbol_150[] = "chunk->indentation_delta = indentation_delta;\n";
-static char symbol_151[] = "chunks->last->next = chunk;\n";
-static char symbol_152[] = "chunks->last = chunk;\n";
-static char symbol_153[] = "fprintf(stderr, \"debug: append chunk = %p\\n\", chunk);\n";
-static char symbol_154[] = "if (chunk->data) {\n";
-static char symbol_155[] = "fprintf(stderr, \"  data = \");\n";
-static char symbol_156[] = "for (int i=0; i<chunk->data->size; i++) {\n";
-static char symbol_157[] = "fprintf(stderr, \"%c\", chunk->data->buffer[i]);\n";
-static char symbol_158[] = "}\n";
-static char symbol_159[] = "fprintf(stderr, \"\\n\");\n";
-static char symbol_160[] = "}\n";
-static char symbol_161[] = "}\n";
-static char symbol_162[] = "\n";
-static char symbol_163[] = "struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {\n";
-static char symbol_164[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
-static char symbol_165[] = "buffer->buffer = data->buffer;\n";
-static char symbol_166[] = "buffer->size = end-start;\n";
-static char symbol_167[] = "buffer->buffer += start;\n";
-static char symbol_168[] = "return buffer;\n";
-static char symbol_169[] = "}\n";
-static char symbol_170[] = "\n";
-static char symbol_171[] = "struct Buffer* buffer_from_cstring(char* data, unsigned int size) {\n";
-static char symbol_172[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
-static char symbol_173[] = "buffer->buffer = data;\n";
-static char symbol_174[] = "buffer->size = size;\n";
-static char symbol_175[] = "return buffer;\n";
-static char symbol_176[] = "}\n";
-static char symbol_177[] = "\n";
-static char symbol_178[] = "struct Buffer* buffer_from_integer(unsigned int value) {\n";
-static char symbol_179[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
-static char symbol_180[] = "buffer->buffer = allocate(20);\n";
-static char symbol_181[] = "sprintf(buffer->buffer, \"%d\", value);\n";
-static char symbol_182[] = "buffer->size = strlen(buffer->buffer);\n";
-static char symbol_183[] = "return buffer;\n";
-static char symbol_184[] = "}\n";
-static char symbol_185[] = "\n";
-static char symbol_186[] = "void run_action(struct Action* action, struct Runtime* runtime) {\n";
-static char symbol_187[] = "if (action->function) {\n";
-static char symbol_188[] = "action->function(runtime, action->variables);\n";
-static char symbol_189[] = "} else {\n";
-static char symbol_190[] = "if (action->variables) {\n";
-static char symbol_191[] = "fprintf(stderr, \"debug_run_action variables\\n\");\n";
-static char symbol_192[] = "struct Variable* variable = action->variables->pre_first->next;\n";
-static char symbol_193[] = "while (variable) {\n";
-static char symbol_194[] = "run_action(variable->action, runtime);\n";
-static char symbol_195[] = "variable = variable->next;\n";
-static char symbol_196[] = "}\n";
-static char symbol_197[] = "} else {\n";
-static char symbol_198[] = "fprintf(stderr, \"debug_run_action else\\n\");\n";
-static char symbol_199[] = "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n";
+static char symbol_97[] = "return parse_state;\n";
+static char symbol_98[] = "}\n";
+static char symbol_99[] = "\n";
+static char symbol_100[] = "struct Chunks* create_chunks() {\n";
+static char symbol_101[] = "struct Chunks* chunks = allocate(sizeof(struct Chunks));\n";
+static char symbol_102[] = "chunks->pre_first = allocate(sizeof(struct Chunk));\n";
+static char symbol_103[] = "chunks->pre_first->next = NULL;\n";
+static char symbol_104[] = "chunks->last = chunks->pre_first;\n";
+static char symbol_105[] = "return chunks;\n";
+static char symbol_106[] = "}\n";
+static char symbol_107[] = "\n";
+static char symbol_108[] = "struct Placeholders* create_placeholders() {\n";
+static char symbol_109[] = "struct Placeholders* placeholders = allocate(sizeof(struct Placeholders));\n";
+static char symbol_110[] = "placeholders->pre_first = allocate(sizeof(struct Placeholder));\n";
+static char symbol_111[] = "placeholders->pre_first->next = NULL;\n";
+static char symbol_112[] = "placeholders->last = placeholders->pre_first;\n";
+static char symbol_113[] = "return placeholders;\n";
+static char symbol_114[] = "}\n";
+static char symbol_115[] = "\n";
+static char symbol_116[] = "struct Runtime* create_runtime() {\n";
+static char symbol_117[] = "struct Runtime* runtime = allocate(sizeof(struct Runtime));\n";
+static char symbol_118[] = "runtime->main_chunks = create_chunks();\n";
+static char symbol_119[] = "runtime->current_chunks = runtime->main_chunks;\n";
+static char symbol_120[] = "runtime->placeholders = create_placeholders();\n";
+static char symbol_121[] = "return runtime;\n";
+static char symbol_122[] = "}\n";
+static char symbol_123[] = "\n";
+static char symbol_124[] = "struct Action* create_action(void (*function)(struct Runtime*, struct Variables*), struct Variables* variables, struct Buffer* input_buffer, unsigned int start, unsigned int end) {\n";
+static char symbol_125[] = "struct Action* action = allocate(sizeof(struct Action));\n";
+static char symbol_126[] = "action->function = function;\n";
+static char symbol_127[] = "action->variables = variables;\n";
+static char symbol_128[] = "action->input_buffer = input_buffer;\n";
+static char symbol_129[] = "action->start = start;\n";
+static char symbol_130[] = "action->end = end;\n";
+static char symbol_131[] = "action->len = end-start;\n";
+static char symbol_132[] = "return action;\n";
+static char symbol_133[] = "}\n";
+static char symbol_134[] = "\n";
+static char symbol_135[] = "struct Variables* create_variables() {\n";
+static char symbol_136[] = "struct Variables* variables = allocate(sizeof(struct Variables));\n";
+static char symbol_137[] = "variables->pre_first = allocate(sizeof(struct Variable));\n";
+static char symbol_138[] = "variables->pre_first->next = NULL;\n";
+static char symbol_139[] = "variables->last = variables->pre_first;\n";
+static char symbol_140[] = "return variables;\n";
+static char symbol_141[] = "}\n";
+static char symbol_142[] = "\n";
+static char symbol_143[] = "void append_data(struct Chunks* chunks, struct Buffer* data, int indentation_delta, struct Chunks* sub_chunks) {\n";
+static char symbol_144[] = "struct Chunk* chunk = allocate(sizeof(struct Chunk));\n";
+static char symbol_145[] = "chunk->next = NULL;\n";
+static char symbol_146[] = "chunk->data = data;\n";
+static char symbol_147[] = "chunk->chunks = sub_chunks;\n";
+static char symbol_148[] = "chunk->indentation_delta = indentation_delta;\n";
+static char symbol_149[] = "chunks->last->next = chunk;\n";
+static char symbol_150[] = "chunks->last = chunk;\n";
+static char symbol_151[] = "}\n";
+static char symbol_152[] = "\n";
+static char symbol_153[] = "struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {\n";
+static char symbol_154[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
+static char symbol_155[] = "buffer->buffer = data->buffer;\n";
+static char symbol_156[] = "buffer->size = end-start;\n";
+static char symbol_157[] = "buffer->buffer += start;\n";
+static char symbol_158[] = "return buffer;\n";
+static char symbol_159[] = "}\n";
+static char symbol_160[] = "\n";
+static char symbol_161[] = "struct Buffer* buffer_from_cstring(char* data, unsigned int size) {\n";
+static char symbol_162[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
+static char symbol_163[] = "buffer->buffer = data;\n";
+static char symbol_164[] = "buffer->size = size;\n";
+static char symbol_165[] = "return buffer;\n";
+static char symbol_166[] = "}\n";
+static char symbol_167[] = "\n";
+static char symbol_168[] = "struct Buffer* buffer_from_integer(unsigned int value) {\n";
+static char symbol_169[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
+static char symbol_170[] = "buffer->buffer = allocate(20);\n";
+static char symbol_171[] = "sprintf(buffer->buffer, \"%d\", value);\n";
+static char symbol_172[] = "buffer->size = strlen(buffer->buffer);\n";
+static char symbol_173[] = "return buffer;\n";
+static char symbol_174[] = "}\n";
+static char symbol_175[] = "\n";
+static char symbol_176[] = "void run_action(struct Action* action, struct Runtime* runtime) {\n";
+static char symbol_177[] = "if (action->function) {\n";
+static char symbol_178[] = "action->function(runtime, action->variables);\n";
+static char symbol_179[] = "} else {\n";
+static char symbol_180[] = "if (action->variables) {\n";
+static char symbol_181[] = "struct Variable* variable = action->variables->pre_first->next;\n";
+static char symbol_182[] = "while (variable) {\n";
+static char symbol_183[] = "run_action(variable->action, runtime);\n";
+static char symbol_184[] = "variable = variable->next;\n";
+static char symbol_185[] = "}\n";
+static char symbol_186[] = "} else {\n";
+static char symbol_187[] = "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n";
+static char symbol_188[] = "}\n";
+static char symbol_189[] = "}\n";
+static char symbol_190[] = "}\n";
+static char symbol_191[] = "\n";
+static char symbol_192[] = "int compare_buffers(struct Buffer* b1, struct Buffer* b2) {\n";
+static char symbol_193[] = "if (b1->size != b2->size) {\n";
+static char symbol_194[] = "return 0;\n";
+static char symbol_195[] = "}\n";
+static char symbol_196[] = "for (int i=0; i<b1->size; i++) {\n";
+static char symbol_197[] = "if (b1->buffer[i] != b2->buffer[i]) {\n";
+static char symbol_198[] = "return 0;\n";
+static char symbol_199[] = "}\n";
 static char symbol_200[] = "}\n";
-static char symbol_201[] = "}\n";
+static char symbol_201[] = "return 1;";
 static char symbol_202[] = "}\n";
 static char symbol_203[] = "\n";
-static char symbol_204[] = "int compare_buffers(struct Buffer* b1, struct Buffer* b2) {\n";
-static char symbol_205[] = "if (b1->size != b2->size) {\n";
-static char symbol_206[] = "return 0;\n";
-static char symbol_207[] = "}\n";
-static char symbol_208[] = "for (int i=0; i<b1->size; i++) {\n";
-static char symbol_209[] = "if (b1->buffer[i] != b2->buffer[i]) {\n";
-static char symbol_210[] = "return 0;\n";
+static char symbol_204[] = "int seen(struct Chunks* chunks, struct Buffer* data) {\n";
+static char symbol_205[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
+static char symbol_206[] = "while (chunk) {\n";
+static char symbol_207[] = "if (compare_buffers(chunk->data, data)) {\n";
+static char symbol_208[] = "return 1;\n";
+static char symbol_209[] = "}\n";
+static char symbol_210[] = "chunk = chunk->next;\n";
 static char symbol_211[] = "}\n";
-static char symbol_212[] = "}\n";
-static char symbol_213[] = "return 1;";
-static char symbol_214[] = "}\n";
-static char symbol_215[] = "\n";
-static char symbol_216[] = "int seen(struct Chunks* chunks, struct Buffer* data) {\n";
-static char symbol_217[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
-static char symbol_218[] = "while (chunk) {\n";
-static char symbol_219[] = "if (compare_buffers(chunk->data, data)) {\n";
-static char symbol_220[] = "return 1;\n";
-static char symbol_221[] = "}\n";
-static char symbol_222[] = "chunk = chunk->next;\n";
-static char symbol_223[] = "}\n";
-static char symbol_224[] = "return 0;\n";
-static char symbol_225[] = "}\n";
-static char symbol_226[] = "\n";
-static char symbol_227[] = "void append_named_action(struct Variables* variables, struct Buffer* name, struct Action* action) {\n";
-static char symbol_228[] = "struct Variable* next_variable = allocate(sizeof(struct Variable));\n";
-static char symbol_229[] = "next_variable->next = NULL;\n";
-static char symbol_230[] = "next_variable->name = name;\n";
-static char symbol_231[] = "next_variable->action = action;\n";
-static char symbol_232[] = "variables->last->next = next_variable;\n";
-static char symbol_233[] = "variables->last = next_variable;\n";
-static char symbol_234[] = "}\n";
-static char symbol_235[] = "\n";
-static char symbol_236[] = "struct Action* lookup_action(struct Variables* variables, struct Buffer* name_to_look_for) {\n";
-static char symbol_237[] = "struct Variable* variable = variables->pre_first->next;\n";
-static char symbol_238[] = "while (variable) {\n";
-static char symbol_239[] = "if (compare_buffers(variable->name, name_to_look_for)) {\n";
-static char symbol_240[] = "fprintf(stderr, \"debug: found action %p\\n\", variable->action);\n";
-static char symbol_241[] = "return variable->action;\n";
-static char symbol_242[] = "} else {\n";
-static char symbol_243[] = "variable = variable->next;\n";
+static char symbol_212[] = "return 0;\n";
+static char symbol_213[] = "}\n";
+static char symbol_214[] = "\n";
+static char symbol_215[] = "void append_named_action(struct Variables* variables, struct Buffer* name, struct Action* action) {\n";
+static char symbol_216[] = "struct Variable* next_variable = allocate(sizeof(struct Variable));\n";
+static char symbol_217[] = "next_variable->next = NULL;\n";
+static char symbol_218[] = "next_variable->name = name;\n";
+static char symbol_219[] = "next_variable->action = action;\n";
+static char symbol_220[] = "variables->last->next = next_variable;\n";
+static char symbol_221[] = "variables->last = next_variable;\n";
+static char symbol_222[] = "}\n";
+static char symbol_223[] = "\n";
+static char symbol_224[] = "struct Action* lookup_action(struct Variables* variables, struct Buffer* name_to_look_for) {\n";
+static char symbol_225[] = "struct Variable* variable = variables->pre_first->next;\n";
+static char symbol_226[] = "while (variable) {\n";
+static char symbol_227[] = "if (compare_buffers(variable->name, name_to_look_for)) {\n";
+static char symbol_228[] = "return variable->action;\n";
+static char symbol_229[] = "} else {\n";
+static char symbol_230[] = "variable = variable->next;\n";
+static char symbol_231[] = "}\n";
+static char symbol_232[] = "}\n";
+static char symbol_233[] = "fprintf(stderr, \"ERROR: variable not found\");\n";
+static char symbol_234[] = "exit(1);\n";
+static char symbol_235[] = "}\n";
+static char symbol_236[] = "\n";
+static char symbol_237[] = "void append_placeholder(struct Placeholders* placeholders, struct Chunks* chunks, struct Action* action) {\n";
+static char symbol_238[] = "struct Placeholder* next_placeholder = allocate(sizeof(struct Placeholder));\n";
+static char symbol_239[] = "next_placeholder->next = NULL;\n";
+static char symbol_240[] = "next_placeholder->chunks = chunks;\n";
+static char symbol_241[] = "next_placeholder->action = action;\n";
+static char symbol_242[] = "placeholders->last->next = next_placeholder;\n";
+static char symbol_243[] = "placeholders->last = next_placeholder;\n";
 static char symbol_244[] = "}\n";
-static char symbol_245[] = "}\n";
-static char symbol_246[] = "fprintf(stderr, \"ERROR: variable not found\");\n";
-static char symbol_247[] = "exit(1);\n";
+static char symbol_245[] = "\n";
+static char symbol_246[] = "unsigned int inc(unsigned int value, unsigned int amount) {\n";
+static char symbol_247[] = "return value + amount;\n";
 static char symbol_248[] = "}\n";
 static char symbol_249[] = "\n";
-static char symbol_250[] = "void append_placeholder(struct Placeholders* placeholders, struct Chunks* chunks, struct Action* action) {\n";
-static char symbol_251[] = "struct Placeholder* next_placeholder = allocate(sizeof(struct Placeholder));\n";
-static char symbol_252[] = "next_placeholder->next = NULL;\n";
-static char symbol_253[] = "next_placeholder->chunks = chunks;\n";
-static char symbol_254[] = "next_placeholder->action = action;\n";
-static char symbol_255[] = "placeholders->last->next = next_placeholder;\n";
-static char symbol_256[] = "placeholders->last = next_placeholder;\n";
-static char symbol_257[] = "}\n";
-static char symbol_258[] = "\n";
-static char symbol_259[] = "unsigned int inc(unsigned int value, unsigned int amount) {\n";
-static char symbol_260[] = "return value + amount;\n";
-static char symbol_261[] = "}\n";
-static char symbol_262[] = "\n";
-static char symbol_263[] = "unsigned int max(unsigned int a, unsigned int b) {\n";
-static char symbol_264[] = "return a > b ? a : b;\n";
+static char symbol_250[] = "unsigned int max(unsigned int a, unsigned int b) {\n";
+static char symbol_251[] = "return a > b ? a : b;\n";
+static char symbol_252[] = "}\n";
+static char symbol_253[] = "\n";
+static char symbol_254[] = "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n";
+static char symbol_255[] = "if (chunks) {\n";
+static char symbol_256[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
+static char symbol_257[] = "while (chunk) {\n";
+static char symbol_258[] = "*indent += chunk->indentation_delta;\n";
+static char symbol_259[] = "if (chunk->data) {\n";
+static char symbol_260[] = "for (int i=0; i<chunk->data->size; i++) {\n";
+static char symbol_261[] = "if (*last_char == '\\n') {\n";
+static char symbol_262[] = "for (int j=0; j<*indent; j++) {\n";
+static char symbol_263[] = "printf(\"    \");\n";
+static char symbol_264[] = "}\n";
 static char symbol_265[] = "}\n";
-static char symbol_266[] = "\n";
-static char symbol_267[] = "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n";
-static char symbol_268[] = "fprintf(stderr, \"debug: render chunks\\n\");\n";
-static char symbol_269[] = "if (chunks) {\n";
-static char symbol_270[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
-static char symbol_271[] = "while (chunk) {\n";
-static char symbol_272[] = "*indent += chunk->indentation_delta;\n";
-static char symbol_273[] = "if (chunk->data) {\n";
-static char symbol_274[] = "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n";
-static char symbol_275[] = "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n";
-static char symbol_276[] = "for (int i=0; i<chunk->data->size; i++) {\n";
-static char symbol_277[] = "if (*last_char == '\\n') {\n";
-static char symbol_278[] = "for (int j=0; j<*indent; j++) {\n";
-static char symbol_279[] = "printf(\"    \");\n";
-static char symbol_280[] = "}\n";
-static char symbol_281[] = "}\n";
-static char symbol_282[] = "*last_char = chunk->data->buffer[i];\n";
-static char symbol_283[] = "putchar(*last_char);\n";
-static char symbol_284[] = "fflush(stdout);\n";
-static char symbol_285[] = "}\n";
-static char symbol_286[] = "}\n";
-static char symbol_287[] = "render_chunks(chunk->chunks, last_char, indent);\n";
-static char symbol_288[] = "chunk = chunk->next;\n";
-static char symbol_289[] = "}\n";
-static char symbol_290[] = "}\n";
-static char symbol_291[] = "}\n";
-static char symbol_292[] = "\n";
-static char symbol_293[] = "\n";
-static char symbol_294[] = "xs";
-static char symbol_295[] = "int main(void) {\n";
-static char symbol_296[] = "arena_limit = 2<<30;\n";
-static char symbol_297[] = "arena_pos = 0;\n";
-static char symbol_298[] = "arena = malloc(arena_limit);\n";
-static char symbol_299[] = "struct ParseState* parse_state = create_parse_state_from_stdin();\n";
-static char symbol_300[] = "char last_char = '\\n';\n";
-static char symbol_301[] = "int indent = 0;\n";
-static char symbol_302[] = "fprintf(stderr, parse_state->input_buffer->buffer);\n";
-static char symbol_303[] = "struct Runtime* runtime = create_runtime();\n";
-static char symbol_304[] = "struct Action* action = rule_main(parse_state);\n";
-static char symbol_305[] = "struct Placeholder* placeholder;\n";
-static char symbol_306[] = "if (action == NULL) {\n";
-static char symbol_307[] = "fprintf(stderr, \"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n";
-static char symbol_308[] = "exit(1);\n";
-static char symbol_309[] = "}\n";
-static char symbol_310[] = "run_action(action, runtime);\n";
-static char symbol_311[] = "placeholder = runtime->placeholders->pre_first->next;\n";
-static char symbol_312[] = "while (placeholder) {\n";
-static char symbol_313[] = "runtime->current_chunks = placeholder->chunks;\n";
-static char symbol_314[] = "run_action(placeholder->action, runtime);\n";
-static char symbol_315[] = "placeholder = placeholder->next;\n";
-static char symbol_316[] = "}\n";
-static char symbol_317[] = "fprintf(stderr, \"debug: arena memory = %p\\n\", arena);\n";
-static char symbol_318[] = "fprintf(stderr, \"debug: arena limit  = %u\\n\", arena_limit);\n";
-static char symbol_319[] = "fprintf(stderr, \"debug: arena used   = %u\\n\", arena_pos);\n";
-static char symbol_320[] = "render_chunks(runtime->main_chunks, &last_char, &indent);\n";
-static char symbol_321[] = "}\n";
-static char symbol_322[] = "x";
-static char symbol_323[] = "=";
-static char symbol_324[] = "y";
-static char symbol_325[] = ";";
-static char symbol_326[] = "struct Action* rule_";
-static char symbol_327[] = "x";
-static char symbol_328[] = "(struct ParseState* parse_state);\n";
-static char symbol_329[] = "struct Action* rule_";
+static char symbol_266[] = "*last_char = chunk->data->buffer[i];\n";
+static char symbol_267[] = "putchar(*last_char);\n";
+static char symbol_268[] = "fflush(stdout);\n";
+static char symbol_269[] = "}\n";
+static char symbol_270[] = "}\n";
+static char symbol_271[] = "render_chunks(chunk->chunks, last_char, indent);\n";
+static char symbol_272[] = "chunk = chunk->next;\n";
+static char symbol_273[] = "}\n";
+static char symbol_274[] = "}\n";
+static char symbol_275[] = "}\n";
+static char symbol_276[] = "\n";
+static char symbol_277[] = "\n";
+static char symbol_278[] = "xs";
+static char symbol_279[] = "int main(void) {\n";
+static char symbol_280[] = "arena_limit = 2<<30;\n";
+static char symbol_281[] = "arena_pos = 0;\n";
+static char symbol_282[] = "arena = malloc(arena_limit);\n";
+static char symbol_283[] = "struct ParseState* parse_state = create_parse_state_from_stdin();\n";
+static char symbol_284[] = "char last_char = '\\n';\n";
+static char symbol_285[] = "int indent = 0;\n";
+static char symbol_286[] = "struct Runtime* runtime = create_runtime();\n";
+static char symbol_287[] = "struct Action* action = rule_main(parse_state);\n";
+static char symbol_288[] = "struct Placeholder* placeholder;\n";
+static char symbol_289[] = "if (action == NULL) {\n";
+static char symbol_290[] = "fprintf(stderr, \"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n";
+static char symbol_291[] = "exit(1);\n";
+static char symbol_292[] = "}\n";
+static char symbol_293[] = "run_action(action, runtime);\n";
+static char symbol_294[] = "placeholder = runtime->placeholders->pre_first->next;\n";
+static char symbol_295[] = "while (placeholder) {\n";
+static char symbol_296[] = "runtime->current_chunks = placeholder->chunks;\n";
+static char symbol_297[] = "run_action(placeholder->action, runtime);\n";
+static char symbol_298[] = "placeholder = placeholder->next;\n";
+static char symbol_299[] = "}\n";
+static char symbol_300[] = "render_chunks(runtime->main_chunks, &last_char, &indent);\n";
+static char symbol_301[] = "}\n";
+static char symbol_302[] = "x";
+static char symbol_303[] = "=";
+static char symbol_304[] = "y";
+static char symbol_305[] = ";";
+static char symbol_306[] = "struct Action* rule_";
+static char symbol_307[] = "x";
+static char symbol_308[] = "(struct ParseState* parse_state);\n";
+static char symbol_309[] = "struct Action* rule_";
+static char symbol_310[] = "x";
+static char symbol_311[] = "(struct ParseState* parse_state) {\n";
+static char symbol_312[] = "unsigned int or_backtrack_pos;\n";
+static char symbol_313[] = "unsigned int action_start_pos;\n";
+static char symbol_314[] = "unsigned int star_start_pos;\n";
+static char symbol_315[] = "unsigned int star_pos;\n";
+static char symbol_316[] = "unsigned int nlookahead_pos;\n";
+static char symbol_317[] = "struct Variables* variables;\n";
+static char symbol_318[] = "struct Variables* star_variables;\n";
+static char symbol_319[] = "struct Action* _;\n";
+static char symbol_320[] = "struct Buffer* data;\n";
+static char symbol_321[] = "y";
+static char symbol_322[] = "return NULL;\n";
+static char symbol_323[] = "}\n";
+static char symbol_324[] = "\n";
+static char symbol_325[] = "x";
+static char symbol_326[] = "xs";
+static char symbol_327[] = "or_backtrack_pos = parse_state->pos;\n";
+static char symbol_328[] = "x";
+static char symbol_329[] = "xs";
 static char symbol_330[] = "x";
-static char symbol_331[] = "(struct ParseState* parse_state) {\n";
-static char symbol_332[] = "unsigned int or_backtrack_pos;\n";
-static char symbol_333[] = "unsigned int action_start_pos;\n";
-static char symbol_334[] = "unsigned int star_start_pos;\n";
-static char symbol_335[] = "unsigned int star_pos;\n";
-static char symbol_336[] = "unsigned int nlookahead_pos;\n";
-static char symbol_337[] = "struct Variables* variables;\n";
-static char symbol_338[] = "struct Variables* star_variables;\n";
-static char symbol_339[] = "struct Action* _;\n";
-static char symbol_340[] = "struct Buffer* data;\n";
-static char symbol_341[] = "fprintf(stderr, \"debug: rule ";
-static char symbol_342[] = "x";
-static char symbol_343[] = " [pos=%d]\\n\", parse_state->pos);\n";
+static char symbol_331[] = "x";
+static char symbol_332[] = "|";
+static char symbol_333[] = "x";
+static char symbol_334[] = "parse_state->pos = or_backtrack_pos;\n";
+static char symbol_335[] = "action_start_pos = parse_state->pos;\n";
+static char symbol_336[] = "variables = create_variables();\n";
+static char symbol_337[] = "x";
+static char symbol_338[] = "x";
+static char symbol_339[] = "y";
+static char symbol_340[] = "x";
+static char symbol_341[] = "if (_) {\n";
+static char symbol_342[] = "y";
+static char symbol_343[] = "}\n";
 static char symbol_344[] = "y";
-static char symbol_345[] = "fprintf(stderr, \"debug: rule fail ";
-static char symbol_346[] = "x";
-static char symbol_347[] = " [pos=%d]\\n\", parse_state->pos);\n";
-static char symbol_348[] = "return NULL;\n";
-static char symbol_349[] = "}\n";
-static char symbol_350[] = "\n";
-static char symbol_351[] = "x";
-static char symbol_352[] = "xs";
-static char symbol_353[] = "or_backtrack_pos = parse_state->pos;\n";
-static char symbol_354[] = "x";
-static char symbol_355[] = "xs";
+static char symbol_345[] = "y";
+static char symbol_346[] = "!";
+static char symbol_347[] = "x";
+static char symbol_348[] = "nlookahead_pos = parse_state->pos;\n";
+static char symbol_349[] = "x";
+static char symbol_350[] = "if (_ == NULL) {\n";
+static char symbol_351[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);\n";
+static char symbol_352[] = "} else {\n";
+static char symbol_353[] = "_ = NULL;\n";
+static char symbol_354[] = "}\n";
+static char symbol_355[] = "parse_state->pos = nlookahead_pos;\n";
 static char symbol_356[] = "x";
-static char symbol_357[] = "x";
-static char symbol_358[] = "|";
-static char symbol_359[] = "x";
-static char symbol_360[] = "parse_state->pos = or_backtrack_pos;\n";
-static char symbol_361[] = "action_start_pos = parse_state->pos;\n";
-static char symbol_362[] = "variables = create_variables();\n";
+static char symbol_357[] = "y";
+static char symbol_358[] = "x";
+static char symbol_359[] = "y";
+static char symbol_360[] = ":";
+static char symbol_361[] = "x";
+static char symbol_362[] = "append_named_action(variables, ";
 static char symbol_363[] = "x";
-static char symbol_364[] = "x";
-static char symbol_365[] = "y";
-static char symbol_366[] = "x";
-static char symbol_367[] = "if (_) {\n";
-static char symbol_368[] = "y";
-static char symbol_369[] = "}\n";
-static char symbol_370[] = "y";
-static char symbol_371[] = "y";
-static char symbol_372[] = "!";
-static char symbol_373[] = "x";
-static char symbol_374[] = "nlookahead_pos = parse_state->pos;\n";
-static char symbol_375[] = "x";
-static char symbol_376[] = "if (_ == NULL) {\n";
-static char symbol_377[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);\n";
-static char symbol_378[] = "} else {\n";
-static char symbol_379[] = "_ = NULL;\n";
-static char symbol_380[] = "}\n";
-static char symbol_381[] = "parse_state->pos = nlookahead_pos;\n";
-static char symbol_382[] = "x";
-static char symbol_383[] = "y";
-static char symbol_384[] = "x";
-static char symbol_385[] = "y";
-static char symbol_386[] = ":";
-static char symbol_387[] = "x";
-static char symbol_388[] = "append_named_action(variables, ";
-static char symbol_389[] = "x";
-static char symbol_390[] = ", _);\n";
-static char symbol_391[] = "x";
-static char symbol_392[] = "*";
-static char symbol_393[] = "star_variables = create_variables();\n";
-static char symbol_394[] = "star_start_pos = parse_state->pos;\n";
-static char symbol_395[] = "while (1) {\n";
-static char symbol_396[] = "star_pos = parse_state->pos;\n";
-static char symbol_397[] = "x";
-static char symbol_398[] = "if (_ == NULL) {\n";
-static char symbol_399[] = "parse_state->pos = star_pos;\n";
-static char symbol_400[] = "break;\n";
+static char symbol_364[] = ", _);\n";
+static char symbol_365[] = "x";
+static char symbol_366[] = "*";
+static char symbol_367[] = "star_variables = create_variables();\n";
+static char symbol_368[] = "star_start_pos = parse_state->pos;\n";
+static char symbol_369[] = "while (1) {\n";
+static char symbol_370[] = "star_pos = parse_state->pos;\n";
+static char symbol_371[] = "x";
+static char symbol_372[] = "if (_ == NULL) {\n";
+static char symbol_373[] = "parse_state->pos = star_pos;\n";
+static char symbol_374[] = "break;\n";
+static char symbol_375[] = "}\n";
+static char symbol_376[] = "append_named_action(star_variables, NULL, _);\n";
+static char symbol_377[] = "}\n";
+static char symbol_378[] = "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n";
+static char symbol_379[] = "x";
+static char symbol_380[] = "x";
+static char symbol_381[] = "x";
+static char symbol_382[] = "_ = rule_";
+static char symbol_383[] = "x";
+static char symbol_384[] = "(parse_state);\n";
+static char symbol_385[] = ".";
+static char symbol_386[] = "if (parse_state->pos < parse_state->input_buffer->size) {\n";
+static char symbol_387[] = "parse_state->pos += 1;\n";
+static char symbol_388[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);\n";
+static char symbol_389[] = "} else {\n";
+static char symbol_390[] = "_ = NULL;\n";
+static char symbol_391[] = "}\n";
+static char symbol_392[] = "x";
+static char symbol_393[] = "data = ";
+static char symbol_394[] = "x";
+static char symbol_395[] = ";\n";
+static char symbol_396[] = "if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {\n";
+static char symbol_397[] = "parse_state->pos += data->size;\n";
+static char symbol_398[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);\n";
+static char symbol_399[] = "} else {\n";
+static char symbol_400[] = "_ = NULL;\n";
 static char symbol_401[] = "}\n";
-static char symbol_402[] = "append_named_action(star_variables, NULL, _);\n";
-static char symbol_403[] = "}\n";
-static char symbol_404[] = "fprintf(stderr, \"debug: creating_star [%d, %d, %p]\\n\", star_start_pos, parse_state->pos, star_variables->pre_first->next);\n";
-static char symbol_405[] = "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n";
-static char symbol_406[] = "x";
-static char symbol_407[] = "x";
-static char symbol_408[] = "x";
-static char symbol_409[] = "_ = rule_";
-static char symbol_410[] = "x";
-static char symbol_411[] = "(parse_state);\n";
-static char symbol_412[] = ".";
-static char symbol_413[] = "if (parse_state->pos < parse_state->input_buffer->size) {\n";
-static char symbol_414[] = "parse_state->pos += 1;\n";
-static char symbol_415[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);\n";
-static char symbol_416[] = "} else {\n";
-static char symbol_417[] = "_ = NULL;\n";
-static char symbol_418[] = "}\n";
-static char symbol_419[] = "x";
-static char symbol_420[] = "data = ";
-static char symbol_421[] = "x";
-static char symbol_422[] = ";\n";
-static char symbol_423[] = "if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {\n";
-static char symbol_424[] = "parse_state->pos += data->size;\n";
-static char symbol_425[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);\n";
-static char symbol_426[] = "} else {\n";
-static char symbol_427[] = "_ = NULL;\n";
-static char symbol_428[] = "}\n";
-static char symbol_429[] = "->";
+static char symbol_402[] = "->";
+static char symbol_403[] = "{";
+static char symbol_404[] = "xs";
+static char symbol_405[] = "}";
+static char symbol_406[] = "void action_";
+static char symbol_407[] = "(struct Runtime* runtime, struct Variables* variables) {\n";
+static char symbol_408[] = "struct Chunks* chunks;\n";
+static char symbol_409[] = "struct Chunks* last_chunks;\n";
+static char symbol_410[] = "struct Action* action;\n";
+static char symbol_411[] = "xs";
+static char symbol_412[] = "}\n";
+static char symbol_413[] = "\n";
+static char symbol_414[] = "return create_action(action_";
+static char symbol_415[] = ", variables, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
+static char symbol_416[] = "return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
+static char symbol_417[] = "unseen(";
+static char symbol_418[] = "x";
+static char symbol_419[] = ") -> {";
+static char symbol_420[] = "ys";
+static char symbol_421[] = "}";
+static char symbol_422[] = "action = lookup_action(variables, ";
+static char symbol_423[] = "x";
+static char symbol_424[] = ");\n";
+static char symbol_425[] = "if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {\n";
+static char symbol_426[] = "ys";
+static char symbol_427[] = "}\n";
+static char symbol_428[] = ">";
+static char symbol_429[] = "x";
 static char symbol_430[] = "{";
-static char symbol_431[] = "xs";
+static char symbol_431[] = "ys";
 static char symbol_432[] = "}";
-static char symbol_433[] = "void action_";
-static char symbol_434[] = "(struct Runtime* runtime, struct Variables* variables) {\n";
-static char symbol_435[] = "struct Chunks* chunks;\n";
-static char symbol_436[] = "struct Chunks* last_chunks;\n";
-static char symbol_437[] = "struct Action* action;\n";
-static char symbol_438[] = "fprintf(stderr, \"debug: running action_";
-static char symbol_439[] = "\\n\");\n";
-static char symbol_440[] = "xs";
-static char symbol_441[] = "}\n";
-static char symbol_442[] = "\n";
-static char symbol_443[] = "return create_action(action_";
-static char symbol_444[] = ", variables, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
-static char symbol_445[] = "return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
-static char symbol_446[] = "unseen(";
+static char symbol_433[] = "last_chunks = runtime->current_chunks;\n";
+static char symbol_434[] = "chunks = runtime->named_chunks_";
+static char symbol_435[] = "x";
+static char symbol_436[] = ";\n";
+static char symbol_437[] = "runtime->current_chunks = chunks;\n";
+static char symbol_438[] = "ys";
+static char symbol_439[] = "runtime->current_chunks = last_chunks;\n";
+static char symbol_440[] = "<";
+static char symbol_441[] = "x";
+static char symbol_442[] = "chunks = create_chunks();\n";
+static char symbol_443[] = "runtime->named_chunks_";
+static char symbol_444[] = "x";
+static char symbol_445[] = " = chunks;\n";
+static char symbol_446[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
 static char symbol_447[] = "x";
-static char symbol_448[] = ") -> {";
-static char symbol_449[] = "ys";
-static char symbol_450[] = "}";
-static char symbol_451[] = "action = lookup_action(variables, ";
-static char symbol_452[] = "x";
-static char symbol_453[] = ");\n";
-static char symbol_454[] = "if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {\n";
-static char symbol_455[] = "ys";
-static char symbol_456[] = "}\n";
-static char symbol_457[] = ">";
-static char symbol_458[] = "x";
-static char symbol_459[] = "{";
-static char symbol_460[] = "ys";
-static char symbol_461[] = "}";
-static char symbol_462[] = "last_chunks = runtime->current_chunks;\n";
-static char symbol_463[] = "chunks = runtime->named_chunks_";
-static char symbol_464[] = "x";
-static char symbol_465[] = ";\n";
-static char symbol_466[] = "runtime->current_chunks = chunks;\n";
-static char symbol_467[] = "ys";
-static char symbol_468[] = "runtime->current_chunks = last_chunks;\n";
-static char symbol_469[] = "<";
-static char symbol_470[] = "x";
-static char symbol_471[] = "chunks = create_chunks();\n";
-static char symbol_472[] = "runtime->named_chunks_";
-static char symbol_473[] = "x";
-static char symbol_474[] = " = chunks;\n";
-static char symbol_475[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
-static char symbol_476[] = "x";
-static char symbol_477[] = "append_data(runtime->current_chunks, buffer_from_integer(";
-static char symbol_478[] = "x";
-static char symbol_479[] = "), 0, NULL);\n";
-static char symbol_480[] = "x";
-static char symbol_481[] = "run_action(lookup_action(variables, ";
-static char symbol_482[] = "x";
-static char symbol_483[] = "), runtime);\n";
-static char symbol_484[] = "x";
-static char symbol_485[] = "void placeholder_";
-static char symbol_486[] = "(struct Runtime* runtime, struct Variables* variables);";
-static char symbol_487[] = "void placeholder_";
-static char symbol_488[] = "(struct Runtime* runtime, struct Variables* variables) {";
-static char symbol_489[] = "x";
-static char symbol_490[] = "}\n";
-static char symbol_491[] = "\n";
-static char symbol_492[] = "chunks = create_chunks();\n";
-static char symbol_493[] = "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_";
-static char symbol_494[] = ", variables, NULL, 0, 0));\n";
-static char symbol_495[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
+static char symbol_448[] = "append_data(runtime->current_chunks, buffer_from_integer(";
+static char symbol_449[] = "x";
+static char symbol_450[] = "), 0, NULL);\n";
+static char symbol_451[] = "x";
+static char symbol_452[] = "run_action(lookup_action(variables, ";
+static char symbol_453[] = "x";
+static char symbol_454[] = "), runtime);\n";
+static char symbol_455[] = "x";
+static char symbol_456[] = "void placeholder_";
+static char symbol_457[] = "(struct Runtime* runtime, struct Variables* variables);";
+static char symbol_458[] = "void placeholder_";
+static char symbol_459[] = "(struct Runtime* runtime, struct Variables* variables) {";
+static char symbol_460[] = "x";
+static char symbol_461[] = "}\n";
+static char symbol_462[] = "\n";
+static char symbol_463[] = "chunks = create_chunks();\n";
+static char symbol_464[] = "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_";
+static char symbol_465[] = ", variables, NULL, 0, 0));\n";
+static char symbol_466[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
+static char symbol_467[] = "x";
+static char symbol_468[] = "append_data(runtime->current_chunks, ";
+static char symbol_469[] = "x";
+static char symbol_470[] = ", 0, NULL);\n";
+static char symbol_471[] = "#";
+static char symbol_472[] = "x";
+static char symbol_473[] = "(";
+static char symbol_474[] = "y";
+static char symbol_475[] = " ";
+static char symbol_476[] = "z";
+static char symbol_477[] = ")";
+static char symbol_478[] = "runtime->W_";
+static char symbol_479[] = "y";
+static char symbol_480[] = " = ";
+static char symbol_481[] = "x";
+static char symbol_482[] = "(runtime->W_";
+static char symbol_483[] = "y";
+static char symbol_484[] = " ? runtime->W_";
+static char symbol_485[] = "y";
+static char symbol_486[] = " : 0, ";
+static char symbol_487[] = "z";
+static char symbol_488[] = ");\n";
+static char symbol_489[] = ">";
+static char symbol_490[] = "xs";
+static char symbol_491[] = "<";
+static char symbol_492[] = "append_data(runtime->current_chunks, NULL, 1, NULL);\n";
+static char symbol_493[] = "xs";
+static char symbol_494[] = "append_data(runtime->current_chunks, NULL, -1, NULL);\n";
+static char symbol_495[] = "x";
 static char symbol_496[] = "x";
-static char symbol_497[] = "append_data(runtime->current_chunks, ";
+static char symbol_497[] = "struct Chunks* named_chunks_";
 static char symbol_498[] = "x";
-static char symbol_499[] = ", 0, NULL);\n";
-static char symbol_500[] = "#";
+static char symbol_499[] = ";\n";
+static char symbol_500[] = "x";
 static char symbol_501[] = "x";
-static char symbol_502[] = "(";
-static char symbol_503[] = "y";
-static char symbol_504[] = " ";
-static char symbol_505[] = "z";
-static char symbol_506[] = ")";
-static char symbol_507[] = "runtime->W_";
-static char symbol_508[] = "y";
-static char symbol_509[] = " = ";
-static char symbol_510[] = "x";
-static char symbol_511[] = "(runtime->W_";
-static char symbol_512[] = "y";
-static char symbol_513[] = " ? runtime->W_";
-static char symbol_514[] = "y";
-static char symbol_515[] = " : 0, ";
-static char symbol_516[] = "z";
-static char symbol_517[] = ");\n";
-static char symbol_518[] = ">";
-static char symbol_519[] = "xs";
-static char symbol_520[] = "<";
-static char symbol_521[] = "append_data(runtime->current_chunks, NULL, 1, NULL);\n";
-static char symbol_522[] = "xs";
-static char symbol_523[] = "append_data(runtime->current_chunks, NULL, -1, NULL);\n";
-static char symbol_524[] = "x";
+static char symbol_502[] = "x";
+static char symbol_503[] = "0";
+static char symbol_504[] = "1";
+static char symbol_505[] = "2";
+static char symbol_506[] = "3";
+static char symbol_507[] = "4";
+static char symbol_508[] = "5";
+static char symbol_509[] = "6";
+static char symbol_510[] = "7";
+static char symbol_511[] = "8";
+static char symbol_512[] = "9";
+static char symbol_513[] = "{";
+static char symbol_514[] = "x";
+static char symbol_515[] = "*";
+static char symbol_516[] = "y";
+static char symbol_517[] = "}";
+static char symbol_518[] = "for (int i=0; i < ";
+static char symbol_519[] = "y";
+static char symbol_520[] = "; i++) {\n";
+static char symbol_521[] = "append_data(runtime->current_chunks, ";
+static char symbol_522[] = "x";
+static char symbol_523[] = ", 0, NULL);\n";
+static char symbol_524[] = "}\n";
 static char symbol_525[] = "x";
-static char symbol_526[] = "struct Chunks* named_chunks_";
+static char symbol_526[] = "(runtime->W_";
 static char symbol_527[] = "x";
-static char symbol_528[] = ";\n";
+static char symbol_528[] = " ? runtime->W_";
 static char symbol_529[] = "x";
-static char symbol_530[] = "x";
-static char symbol_531[] = "x";
-static char symbol_532[] = "0";
-static char symbol_533[] = "1";
-static char symbol_534[] = "2";
-static char symbol_535[] = "3";
-static char symbol_536[] = "4";
-static char symbol_537[] = "5";
-static char symbol_538[] = "6";
-static char symbol_539[] = "7";
-static char symbol_540[] = "8";
-static char symbol_541[] = "9";
-static char symbol_542[] = "{";
-static char symbol_543[] = "x";
-static char symbol_544[] = "*";
-static char symbol_545[] = "y";
-static char symbol_546[] = "}";
-static char symbol_547[] = "for (int i=0; i < ";
-static char symbol_548[] = "y";
-static char symbol_549[] = "; i++) {\n";
-static char symbol_550[] = "append_data(runtime->current_chunks, ";
-static char symbol_551[] = "x";
-static char symbol_552[] = ", 0, NULL);\n";
-static char symbol_553[] = "}\n";
-static char symbol_554[] = "x";
-static char symbol_555[] = "(runtime->W_";
+static char symbol_530[] = " : 0)";
+static char symbol_531[] = "(";
+static char symbol_532[] = "x";
+static char symbol_533[] = "-";
+static char symbol_534[] = "y";
+static char symbol_535[] = ")";
+static char symbol_536[] = "((runtime->W_";
+static char symbol_537[] = "x";
+static char symbol_538[] = " ? runtime->W_";
+static char symbol_539[] = "x";
+static char symbol_540[] = " : 0)-";
+static char symbol_541[] = "y";
+static char symbol_542[] = ")";
+static char symbol_543[] = "\"";
+static char symbol_544[] = "xs";
+static char symbol_545[] = "\"";
+static char symbol_546[] = "static char symbol_";
+static char symbol_547[] = "[] = \"";
+static char symbol_548[] = "xs";
+static char symbol_549[] = "\";\n";
+static char symbol_550[] = "buffer_from_cstring(symbol_";
+static char symbol_551[] = ", sizeof(symbol_";
+static char symbol_552[] = ")-1)";
+static char symbol_553[] = "x";
+static char symbol_554[] = "xs";
+static char symbol_555[] = "lookup_action(variables, ";
 static char symbol_556[] = "x";
-static char symbol_557[] = " ? runtime->W_";
-static char symbol_558[] = "x";
-static char symbol_559[] = " : 0)";
-static char symbol_560[] = "(";
-static char symbol_561[] = "x";
-static char symbol_562[] = "-";
-static char symbol_563[] = "y";
-static char symbol_564[] = ")";
-static char symbol_565[] = "((runtime->W_";
+static char symbol_557[] = ")";
+static char symbol_558[] = "xs";
+static char symbol_559[] = ".";
+static char symbol_560[] = "x";
+static char symbol_561[] = "->";
+static char symbol_562[] = "x";
+static char symbol_563[] = "W[";
+static char symbol_564[] = "x";
+static char symbol_565[] = "]";
 static char symbol_566[] = "x";
-static char symbol_567[] = " ? runtime->W_";
+static char symbol_567[] = "unsigned int W_";
 static char symbol_568[] = "x";
-static char symbol_569[] = " : 0)-";
-static char symbol_570[] = "y";
-static char symbol_571[] = ")";
+static char symbol_569[] = ";\n";
+static char symbol_570[] = "x";
+static char symbol_571[] = "\\\"";
 static char symbol_572[] = "\"";
 static char symbol_573[] = "xs";
-static char symbol_574[] = "\"";
-static char symbol_575[] = "static char symbol_";
-static char symbol_576[] = "[] = \"";
-static char symbol_577[] = "xs";
-static char symbol_578[] = "\";\n";
-static char symbol_579[] = "buffer_from_cstring(symbol_";
-static char symbol_580[] = ", sizeof(symbol_";
-static char symbol_581[] = ")-1)";
-static char symbol_582[] = "x";
-static char symbol_583[] = "xs";
-static char symbol_584[] = "lookup_action(variables, ";
+static char symbol_574[] = "static char symbol_";
+static char symbol_575[] = "[] = \"";
+static char symbol_576[] = "xs";
+static char symbol_577[] = "\";\n";
+static char symbol_578[] = "buffer_from_cstring(symbol_";
+static char symbol_579[] = ", sizeof(symbol_";
+static char symbol_580[] = ")-1)";
+static char symbol_581[] = "\'";
+static char symbol_582[] = "\\\'";
+static char symbol_583[] = "\"";
+static char symbol_584[] = "\\\"";
 static char symbol_585[] = "x";
-static char symbol_586[] = ")";
-static char symbol_587[] = "xs";
-static char symbol_588[] = ".";
-static char symbol_589[] = "x";
-static char symbol_590[] = "->";
-static char symbol_591[] = "x";
-static char symbol_592[] = "W[";
-static char symbol_593[] = "x";
-static char symbol_594[] = "]";
-static char symbol_595[] = "x";
-static char symbol_596[] = "unsigned int W_";
-static char symbol_597[] = "x";
-static char symbol_598[] = ";\n";
-static char symbol_599[] = "x";
-static char symbol_600[] = "\\\"";
-static char symbol_601[] = "\"";
-static char symbol_602[] = "xs";
-static char symbol_603[] = "static char symbol_";
-static char symbol_604[] = "[] = \"";
-static char symbol_605[] = "xs";
-static char symbol_606[] = "\";\n";
-static char symbol_607[] = "buffer_from_cstring(symbol_";
-static char symbol_608[] = ", sizeof(symbol_";
-static char symbol_609[] = ")-1)";
-static char symbol_610[] = "\'";
-static char symbol_611[] = "\\\'";
-static char symbol_612[] = "\"";
-static char symbol_613[] = "\\\"";
-static char symbol_614[] = "x";
-static char symbol_615[] = "static char symbol_";
-static char symbol_616[] = "[] = \"";
-static char symbol_617[] = "x";
-static char symbol_618[] = "\";\n";
-static char symbol_619[] = "buffer_from_cstring(symbol_";
-static char symbol_620[] = ", sizeof(symbol_";
-static char symbol_621[] = ")-1)";
-static char symbol_622[] = "a";
-static char symbol_623[] = "b";
-static char symbol_624[] = "c";
-static char symbol_625[] = "d";
-static char symbol_626[] = "e";
-static char symbol_627[] = "f";
-static char symbol_628[] = "g";
-static char symbol_629[] = "h";
-static char symbol_630[] = "i";
-static char symbol_631[] = "j";
-static char symbol_632[] = "k";
-static char symbol_633[] = "l";
-static char symbol_634[] = "m";
-static char symbol_635[] = "n";
-static char symbol_636[] = "o";
-static char symbol_637[] = "p";
-static char symbol_638[] = "q";
-static char symbol_639[] = "r";
-static char symbol_640[] = "s";
-static char symbol_641[] = "t";
-static char symbol_642[] = "u";
-static char symbol_643[] = "v";
-static char symbol_644[] = "w";
-static char symbol_645[] = "x";
-static char symbol_646[] = "y";
-static char symbol_647[] = "z";
-static char symbol_648[] = "A";
-static char symbol_649[] = "B";
-static char symbol_650[] = "C";
-static char symbol_651[] = "D";
-static char symbol_652[] = "E";
-static char symbol_653[] = "F";
-static char symbol_654[] = "G";
-static char symbol_655[] = "H";
-static char symbol_656[] = "I";
-static char symbol_657[] = "J";
-static char symbol_658[] = "K";
-static char symbol_659[] = "L";
-static char symbol_660[] = "M";
-static char symbol_661[] = "N";
-static char symbol_662[] = "O";
-static char symbol_663[] = "P";
-static char symbol_664[] = "Q";
-static char symbol_665[] = "R";
-static char symbol_666[] = "S";
-static char symbol_667[] = "T";
-static char symbol_668[] = "U";
-static char symbol_669[] = "V";
-static char symbol_670[] = "W";
-static char symbol_671[] = "X";
-static char symbol_672[] = "Y";
-static char symbol_673[] = "Z";
-static char symbol_674[] = " ";
-static char symbol_675[] = "\n";
+static char symbol_586[] = "static char symbol_";
+static char symbol_587[] = "[] = \"";
+static char symbol_588[] = "x";
+static char symbol_589[] = "\";\n";
+static char symbol_590[] = "buffer_from_cstring(symbol_";
+static char symbol_591[] = ", sizeof(symbol_";
+static char symbol_592[] = ")-1)";
+static char symbol_593[] = "a";
+static char symbol_594[] = "b";
+static char symbol_595[] = "c";
+static char symbol_596[] = "d";
+static char symbol_597[] = "e";
+static char symbol_598[] = "f";
+static char symbol_599[] = "g";
+static char symbol_600[] = "h";
+static char symbol_601[] = "i";
+static char symbol_602[] = "j";
+static char symbol_603[] = "k";
+static char symbol_604[] = "l";
+static char symbol_605[] = "m";
+static char symbol_606[] = "n";
+static char symbol_607[] = "o";
+static char symbol_608[] = "p";
+static char symbol_609[] = "q";
+static char symbol_610[] = "r";
+static char symbol_611[] = "s";
+static char symbol_612[] = "t";
+static char symbol_613[] = "u";
+static char symbol_614[] = "v";
+static char symbol_615[] = "w";
+static char symbol_616[] = "x";
+static char symbol_617[] = "y";
+static char symbol_618[] = "z";
+static char symbol_619[] = "A";
+static char symbol_620[] = "B";
+static char symbol_621[] = "C";
+static char symbol_622[] = "D";
+static char symbol_623[] = "E";
+static char symbol_624[] = "F";
+static char symbol_625[] = "G";
+static char symbol_626[] = "H";
+static char symbol_627[] = "I";
+static char symbol_628[] = "J";
+static char symbol_629[] = "K";
+static char symbol_630[] = "L";
+static char symbol_631[] = "M";
+static char symbol_632[] = "N";
+static char symbol_633[] = "O";
+static char symbol_634[] = "P";
+static char symbol_635[] = "Q";
+static char symbol_636[] = "R";
+static char symbol_637[] = "S";
+static char symbol_638[] = "T";
+static char symbol_639[] = "U";
+static char symbol_640[] = "V";
+static char symbol_641[] = "W";
+static char symbol_642[] = "X";
+static char symbol_643[] = "Y";
+static char symbol_644[] = "Z";
+static char symbol_645[] = " ";
+static char symbol_646[] = "\n";
 struct Action* rule_main(struct ParseState* parse_state);
 struct Action* rule_file(struct ParseState* parse_state);
 struct Action* rule_rule(struct ParseState* parse_state);
@@ -1009,7 +964,6 @@ void action_1(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_1\n");
     run_action(lookup_action(variables, buffer_from_cstring(symbol_2, sizeof(symbol_2)-1)), runtime);
 }
 
@@ -1017,7 +971,6 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_2\n");
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_4, sizeof(symbol_4)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_5, sizeof(symbol_5)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_6, sizeof(symbol_6)-1), 0, NULL);
@@ -1145,42 +1098,42 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_95, sizeof(symbol_95)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_96, sizeof(symbol_96)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_97, sizeof(symbol_97)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_98, sizeof(symbol_98)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_98, sizeof(symbol_98)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_99, sizeof(symbol_99)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_100, sizeof(symbol_100)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_101, sizeof(symbol_101)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_101, sizeof(symbol_101)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_102, sizeof(symbol_102)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_103, sizeof(symbol_103)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_104, sizeof(symbol_104)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_105, sizeof(symbol_105)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_106, sizeof(symbol_106)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_106, sizeof(symbol_106)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_107, sizeof(symbol_107)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_108, sizeof(symbol_108)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_109, sizeof(symbol_109)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_109, sizeof(symbol_109)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_110, sizeof(symbol_110)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_111, sizeof(symbol_111)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_112, sizeof(symbol_112)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_113, sizeof(symbol_113)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_114, sizeof(symbol_114)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_114, sizeof(symbol_114)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_115, sizeof(symbol_115)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_116, sizeof(symbol_116)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_117, sizeof(symbol_117)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_117, sizeof(symbol_117)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_118, sizeof(symbol_118)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_119, sizeof(symbol_119)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_120, sizeof(symbol_120)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_121, sizeof(symbol_121)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_122, sizeof(symbol_122)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_122, sizeof(symbol_122)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_123, sizeof(symbol_123)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_124, sizeof(symbol_124)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_125, sizeof(symbol_125)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_125, sizeof(symbol_125)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_126, sizeof(symbol_126)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_127, sizeof(symbol_127)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_128, sizeof(symbol_128)-1), 0, NULL);
@@ -1188,100 +1141,104 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_130, sizeof(symbol_130)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_131, sizeof(symbol_131)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_132, sizeof(symbol_132)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_133, sizeof(symbol_133)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_134, sizeof(symbol_134)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_135, sizeof(symbol_135)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_136, sizeof(symbol_136)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_137, sizeof(symbol_137)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_138, sizeof(symbol_138)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_139, sizeof(symbol_139)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_140, sizeof(symbol_140)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_141, sizeof(symbol_141)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_142, sizeof(symbol_142)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_143, sizeof(symbol_143)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_144, sizeof(symbol_144)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_145, sizeof(symbol_145)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_146, sizeof(symbol_146)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_147, sizeof(symbol_147)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_148, sizeof(symbol_148)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_149, sizeof(symbol_149)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_150, sizeof(symbol_150)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_151, sizeof(symbol_151)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_152, sizeof(symbol_152)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_153, sizeof(symbol_153)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_154, sizeof(symbol_154)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_154, sizeof(symbol_154)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_155, sizeof(symbol_155)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_156, sizeof(symbol_156)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_157, sizeof(symbol_157)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_158, sizeof(symbol_158)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_159, sizeof(symbol_159)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_159, sizeof(symbol_159)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_160, sizeof(symbol_160)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_161, sizeof(symbol_161)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_162, sizeof(symbol_162)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_163, sizeof(symbol_163)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_164, sizeof(symbol_164)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_165, sizeof(symbol_165)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_166, sizeof(symbol_166)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_167, sizeof(symbol_167)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_168, sizeof(symbol_168)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_169, sizeof(symbol_169)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_170, sizeof(symbol_170)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_171, sizeof(symbol_171)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_172, sizeof(symbol_172)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_173, sizeof(symbol_173)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_174, sizeof(symbol_174)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_175, sizeof(symbol_175)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_176, sizeof(symbol_176)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_177, sizeof(symbol_177)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_178, sizeof(symbol_178)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_178, sizeof(symbol_178)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_179, sizeof(symbol_179)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_180, sizeof(symbol_180)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_181, sizeof(symbol_181)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_182, sizeof(symbol_182)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_183, sizeof(symbol_183)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_184, sizeof(symbol_184)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_185, sizeof(symbol_185)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_186, sizeof(symbol_186)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_187, sizeof(symbol_187)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_188, sizeof(symbol_188)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_189, sizeof(symbol_189)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_190, sizeof(symbol_190)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_191, sizeof(symbol_191)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_192, sizeof(symbol_192)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_193, sizeof(symbol_193)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_194, sizeof(symbol_194)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_195, sizeof(symbol_195)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_195, sizeof(symbol_195)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_196, sizeof(symbol_196)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_197, sizeof(symbol_197)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_198, sizeof(symbol_198)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_199, sizeof(symbol_199)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_200, sizeof(symbol_200)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_201, sizeof(symbol_201)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_202, sizeof(symbol_202)-1), 0, NULL);
@@ -1289,69 +1246,65 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_204, sizeof(symbol_204)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_205, sizeof(symbol_205)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_206, sizeof(symbol_206)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_207, sizeof(symbol_207)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_208, sizeof(symbol_208)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_208, sizeof(symbol_208)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_209, sizeof(symbol_209)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_210, sizeof(symbol_210)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_211, sizeof(symbol_211)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_212, sizeof(symbol_212)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_213, sizeof(symbol_213)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_213, sizeof(symbol_213)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_214, sizeof(symbol_214)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_215, sizeof(symbol_215)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_216, sizeof(symbol_216)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_216, sizeof(symbol_216)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_217, sizeof(symbol_217)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_218, sizeof(symbol_218)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_219, sizeof(symbol_219)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_220, sizeof(symbol_220)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_221, sizeof(symbol_221)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_222, sizeof(symbol_222)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_222, sizeof(symbol_222)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_223, sizeof(symbol_223)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_224, sizeof(symbol_224)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_225, sizeof(symbol_225)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_226, sizeof(symbol_226)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_227, sizeof(symbol_227)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_228, sizeof(symbol_228)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_229, sizeof(symbol_229)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_230, sizeof(symbol_230)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_231, sizeof(symbol_231)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_232, sizeof(symbol_232)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_233, sizeof(symbol_233)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_234, sizeof(symbol_234)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_235, sizeof(symbol_235)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_236, sizeof(symbol_236)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_237, sizeof(symbol_237)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_238, sizeof(symbol_238)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_238, sizeof(symbol_238)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_239, sizeof(symbol_239)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_240, sizeof(symbol_240)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_241, sizeof(symbol_241)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_242, sizeof(symbol_242)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_243, sizeof(symbol_243)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_244, sizeof(symbol_244)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_245, sizeof(symbol_245)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_246, sizeof(symbol_246)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_247, sizeof(symbol_247)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_248, sizeof(symbol_248)-1), 0, NULL);
@@ -1359,680 +1312,607 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_250, sizeof(symbol_250)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_251, sizeof(symbol_251)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_252, sizeof(symbol_252)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_253, sizeof(symbol_253)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_254, sizeof(symbol_254)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_255, sizeof(symbol_255)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_256, sizeof(symbol_256)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_257, sizeof(symbol_257)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_258, sizeof(symbol_258)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_259, sizeof(symbol_259)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_260, sizeof(symbol_260)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_261, sizeof(symbol_261)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_262, sizeof(symbol_262)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_263, sizeof(symbol_263)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_263, sizeof(symbol_263)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_264, sizeof(symbol_264)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_265, sizeof(symbol_265)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_266, sizeof(symbol_266)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_267, sizeof(symbol_267)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_268, sizeof(symbol_268)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_269, sizeof(symbol_269)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_270, sizeof(symbol_270)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_271, sizeof(symbol_271)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_272, sizeof(symbol_272)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_273, sizeof(symbol_273)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_274, sizeof(symbol_274)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_275, sizeof(symbol_275)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_276, sizeof(symbol_276)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    chunks = create_chunks();
+    runtime->named_chunks_symbols = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    chunks = create_chunks();
+    runtime->named_chunks_definitions = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_277, sizeof(symbol_277)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_278, sizeof(symbol_278)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    chunks = create_chunks();
+    runtime->named_chunks_actions = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    chunks = create_chunks();
+    runtime->named_chunks_placeholders = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_278, sizeof(symbol_278)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_279, sizeof(symbol_279)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_280, sizeof(symbol_280)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_281, sizeof(symbol_281)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_282, sizeof(symbol_282)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_283, sizeof(symbol_283)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_284, sizeof(symbol_284)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_285, sizeof(symbol_285)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_286, sizeof(symbol_286)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_287, sizeof(symbol_287)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_288, sizeof(symbol_288)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_289, sizeof(symbol_289)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_290, sizeof(symbol_290)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_291, sizeof(symbol_291)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_292, sizeof(symbol_292)-1), 0, NULL);
-    chunks = create_chunks();
-    runtime->named_chunks_symbols = chunks;
-    append_data(runtime->current_chunks, NULL, 0, chunks);
-    chunks = create_chunks();
-    runtime->named_chunks_definitions = chunks;
-    append_data(runtime->current_chunks, NULL, 0, chunks);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_293, sizeof(symbol_293)-1), 0, NULL);
-    chunks = create_chunks();
-    runtime->named_chunks_actions = chunks;
-    append_data(runtime->current_chunks, NULL, 0, chunks);
-    chunks = create_chunks();
-    runtime->named_chunks_placeholders = chunks;
-    append_data(runtime->current_chunks, NULL, 0, chunks);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_294, sizeof(symbol_294)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_294, sizeof(symbol_294)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_295, sizeof(symbol_295)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_296, sizeof(symbol_296)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_297, sizeof(symbol_297)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_298, sizeof(symbol_298)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_299, sizeof(symbol_299)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_300, sizeof(symbol_300)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_301, sizeof(symbol_301)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_302, sizeof(symbol_302)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_303, sizeof(symbol_303)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_304, sizeof(symbol_304)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_305, sizeof(symbol_305)-1), 0, NULL);
+}
+
+void action_3(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_definitions;
+    runtime->current_chunks = chunks;
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_306, sizeof(symbol_306)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_307, sizeof(symbol_307)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_307, sizeof(symbol_307)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_308, sizeof(symbol_308)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    runtime->current_chunks = last_chunks;
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_309, sizeof(symbol_309)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_310, sizeof(symbol_310)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_310, sizeof(symbol_310)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_311, sizeof(symbol_311)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_312, sizeof(symbol_312)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_312, sizeof(symbol_312)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_313, sizeof(symbol_313)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_314, sizeof(symbol_314)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_315, sizeof(symbol_315)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_316, sizeof(symbol_316)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_317, sizeof(symbol_317)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_318, sizeof(symbol_318)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_319, sizeof(symbol_319)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_320, sizeof(symbol_320)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_321, sizeof(symbol_321)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_322, sizeof(symbol_322)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_321, sizeof(symbol_321)-1), 0, NULL);
-}
-
-void action_3(struct Runtime* runtime, struct Variables* variables) {
-    struct Chunks* chunks;
-    struct Chunks* last_chunks;
-    struct Action* action;
-    fprintf(stderr, "debug: running action_3\n");
-    last_chunks = runtime->current_chunks;
-    chunks = runtime->named_chunks_definitions;
-    runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_326, sizeof(symbol_326)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_327, sizeof(symbol_327)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_328, sizeof(symbol_328)-1), 0, NULL);
-    runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_329, sizeof(symbol_329)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_330, sizeof(symbol_330)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_331, sizeof(symbol_331)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_332, sizeof(symbol_332)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_333, sizeof(symbol_333)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_334, sizeof(symbol_334)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_335, sizeof(symbol_335)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_336, sizeof(symbol_336)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_337, sizeof(symbol_337)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_338, sizeof(symbol_338)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_339, sizeof(symbol_339)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_340, sizeof(symbol_340)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_341, sizeof(symbol_341)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_342, sizeof(symbol_342)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_343, sizeof(symbol_343)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_344, sizeof(symbol_344)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_345, sizeof(symbol_345)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_346, sizeof(symbol_346)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_347, sizeof(symbol_347)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_348, sizeof(symbol_348)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_349, sizeof(symbol_349)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_350, sizeof(symbol_350)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_323, sizeof(symbol_323)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_324, sizeof(symbol_324)-1), 0, NULL);
 }
 
 void action_4(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_4\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_353, sizeof(symbol_353)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_354, sizeof(symbol_354)-1)), runtime);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_355, sizeof(symbol_355)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_327, sizeof(symbol_327)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_328, sizeof(symbol_328)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_329, sizeof(symbol_329)-1)), runtime);
 }
 
 void action_5(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_5\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_357, sizeof(symbol_357)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_331, sizeof(symbol_331)-1)), runtime);
 }
 
 void action_6(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_6\n");
 }
 
 void action_7(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_7\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_360, sizeof(symbol_360)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_361, sizeof(symbol_361)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_362, sizeof(symbol_362)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_363, sizeof(symbol_363)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_334, sizeof(symbol_334)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_335, sizeof(symbol_335)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_336, sizeof(symbol_336)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_337, sizeof(symbol_337)-1)), runtime);
 }
 
 void action_8(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_8\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_366, sizeof(symbol_366)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_367, sizeof(symbol_367)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_340, sizeof(symbol_340)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_341, sizeof(symbol_341)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_368, sizeof(symbol_368)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_342, sizeof(symbol_342)-1)), runtime);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_369, sizeof(symbol_369)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_343, sizeof(symbol_343)-1), 0, NULL);
 }
 
 void action_9(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_9\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_371, sizeof(symbol_371)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_345, sizeof(symbol_345)-1)), runtime);
 }
 
 void action_10(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_10\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_374, sizeof(symbol_374)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_375, sizeof(symbol_375)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_376, sizeof(symbol_376)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_348, sizeof(symbol_348)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_349, sizeof(symbol_349)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_350, sizeof(symbol_350)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_377, sizeof(symbol_377)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_351, sizeof(symbol_351)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_378, sizeof(symbol_378)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_352, sizeof(symbol_352)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_379, sizeof(symbol_379)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_353, sizeof(symbol_353)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_380, sizeof(symbol_380)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_381, sizeof(symbol_381)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_354, sizeof(symbol_354)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_355, sizeof(symbol_355)-1), 0, NULL);
 }
 
 void action_11(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_11\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_384, sizeof(symbol_384)-1)), runtime);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_385, sizeof(symbol_385)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_358, sizeof(symbol_358)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_359, sizeof(symbol_359)-1)), runtime);
 }
 
 void action_12(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_12\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_388, sizeof(symbol_388)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_389, sizeof(symbol_389)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_390, sizeof(symbol_390)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_362, sizeof(symbol_362)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_363, sizeof(symbol_363)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_364, sizeof(symbol_364)-1), 0, NULL);
 }
 
 void action_13(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_13\n");
 }
 
 void action_14(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_14\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_393, sizeof(symbol_393)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_394, sizeof(symbol_394)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_395, sizeof(symbol_395)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_367, sizeof(symbol_367)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_368, sizeof(symbol_368)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_369, sizeof(symbol_369)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_396, sizeof(symbol_396)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_397, sizeof(symbol_397)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_398, sizeof(symbol_398)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_370, sizeof(symbol_370)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_371, sizeof(symbol_371)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_372, sizeof(symbol_372)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_399, sizeof(symbol_399)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_400, sizeof(symbol_400)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_373, sizeof(symbol_373)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_374, sizeof(symbol_374)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_401, sizeof(symbol_401)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_402, sizeof(symbol_402)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_375, sizeof(symbol_375)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_376, sizeof(symbol_376)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_403, sizeof(symbol_403)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_404, sizeof(symbol_404)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_405, sizeof(symbol_405)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_377, sizeof(symbol_377)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_378, sizeof(symbol_378)-1), 0, NULL);
 }
 
 void action_15(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_15\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_407, sizeof(symbol_407)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_380, sizeof(symbol_380)-1)), runtime);
 }
 
 void action_16(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_16\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_409, sizeof(symbol_409)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_410, sizeof(symbol_410)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_411, sizeof(symbol_411)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_382, sizeof(symbol_382)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_383, sizeof(symbol_383)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_384, sizeof(symbol_384)-1), 0, NULL);
 }
 
 void action_17(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_17\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_413, sizeof(symbol_413)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_386, sizeof(symbol_386)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_414, sizeof(symbol_414)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_415, sizeof(symbol_415)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_387, sizeof(symbol_387)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_388, sizeof(symbol_388)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_416, sizeof(symbol_416)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_389, sizeof(symbol_389)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_417, sizeof(symbol_417)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_390, sizeof(symbol_390)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_418, sizeof(symbol_418)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_391, sizeof(symbol_391)-1), 0, NULL);
 }
 
 void action_18(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_18\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_420, sizeof(symbol_420)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_421, sizeof(symbol_421)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_422, sizeof(symbol_422)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_423, sizeof(symbol_423)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_393, sizeof(symbol_393)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_394, sizeof(symbol_394)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_395, sizeof(symbol_395)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_396, sizeof(symbol_396)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_424, sizeof(symbol_424)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_425, sizeof(symbol_425)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_397, sizeof(symbol_397)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_398, sizeof(symbol_398)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_426, sizeof(symbol_426)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_399, sizeof(symbol_399)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_427, sizeof(symbol_427)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_400, sizeof(symbol_400)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_428, sizeof(symbol_428)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_401, sizeof(symbol_401)-1), 0, NULL);
 }
 
 void action_19(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_19\n");
     runtime->W_0 = inc(runtime->W_0 ? runtime->W_0 : 0, 1);
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_actions;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_433, sizeof(symbol_433)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_406, sizeof(symbol_406)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_434, sizeof(symbol_434)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_407, sizeof(symbol_407)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_435, sizeof(symbol_435)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_436, sizeof(symbol_436)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_437, sizeof(symbol_437)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_438, sizeof(symbol_438)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_439, sizeof(symbol_439)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_440, sizeof(symbol_440)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_408, sizeof(symbol_408)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_409, sizeof(symbol_409)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_410, sizeof(symbol_410)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_411, sizeof(symbol_411)-1)), runtime);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_441, sizeof(symbol_441)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_442, sizeof(symbol_442)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_412, sizeof(symbol_412)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_413, sizeof(symbol_413)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_443, sizeof(symbol_443)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_414, sizeof(symbol_414)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_444, sizeof(symbol_444)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_415, sizeof(symbol_415)-1), 0, NULL);
 }
 
 void action_20(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_20\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_445, sizeof(symbol_445)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_416, sizeof(symbol_416)-1), 0, NULL);
 }
 
 void action_21(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_21\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_451, sizeof(symbol_451)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_452, sizeof(symbol_452)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_453, sizeof(symbol_453)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_454, sizeof(symbol_454)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_422, sizeof(symbol_422)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_423, sizeof(symbol_423)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_424, sizeof(symbol_424)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_425, sizeof(symbol_425)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_455, sizeof(symbol_455)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_426, sizeof(symbol_426)-1)), runtime);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_456, sizeof(symbol_456)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_427, sizeof(symbol_427)-1), 0, NULL);
 }
 
 void action_22(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_22\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_462, sizeof(symbol_462)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_463, sizeof(symbol_463)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_464, sizeof(symbol_464)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_465, sizeof(symbol_465)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_466, sizeof(symbol_466)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_467, sizeof(symbol_467)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_468, sizeof(symbol_468)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_433, sizeof(symbol_433)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_434, sizeof(symbol_434)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_435, sizeof(symbol_435)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_436, sizeof(symbol_436)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_437, sizeof(symbol_437)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_438, sizeof(symbol_438)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_439, sizeof(symbol_439)-1), 0, NULL);
 }
 
 void action_23(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_23\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_471, sizeof(symbol_471)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_472, sizeof(symbol_472)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_473, sizeof(symbol_473)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_474, sizeof(symbol_474)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_475, sizeof(symbol_475)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_442, sizeof(symbol_442)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_443, sizeof(symbol_443)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_444, sizeof(symbol_444)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_445, sizeof(symbol_445)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_446, sizeof(symbol_446)-1), 0, NULL);
 }
 
 void action_24(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_24\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_477, sizeof(symbol_477)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_478, sizeof(symbol_478)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_479, sizeof(symbol_479)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_448, sizeof(symbol_448)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_449, sizeof(symbol_449)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_450, sizeof(symbol_450)-1), 0, NULL);
 }
 
 void action_25(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_25\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_481, sizeof(symbol_481)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_482, sizeof(symbol_482)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_483, sizeof(symbol_483)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_452, sizeof(symbol_452)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_453, sizeof(symbol_453)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_454, sizeof(symbol_454)-1), 0, NULL);
 }
 
 void action_26(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_26\n");
     runtime->W_1 = inc(runtime->W_1 ? runtime->W_1 : 0, 1);
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_definitions;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_485, sizeof(symbol_485)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_456, sizeof(symbol_456)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_486, sizeof(symbol_486)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_457, sizeof(symbol_457)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_placeholders;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_487, sizeof(symbol_487)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_458, sizeof(symbol_458)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_488, sizeof(symbol_488)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_459, sizeof(symbol_459)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_489, sizeof(symbol_489)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_460, sizeof(symbol_460)-1)), runtime);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_490, sizeof(symbol_490)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_491, sizeof(symbol_491)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_461, sizeof(symbol_461)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_462, sizeof(symbol_462)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_492, sizeof(symbol_492)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_493, sizeof(symbol_493)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_463, sizeof(symbol_463)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_464, sizeof(symbol_464)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_494, sizeof(symbol_494)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_495, sizeof(symbol_495)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_465, sizeof(symbol_465)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_466, sizeof(symbol_466)-1), 0, NULL);
 }
 
 void action_27(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_27\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_497, sizeof(symbol_497)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_498, sizeof(symbol_498)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_499, sizeof(symbol_499)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_468, sizeof(symbol_468)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_469, sizeof(symbol_469)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_470, sizeof(symbol_470)-1), 0, NULL);
 }
 
 void action_28(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_28\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_507, sizeof(symbol_507)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_508, sizeof(symbol_508)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_509, sizeof(symbol_509)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_510, sizeof(symbol_510)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_511, sizeof(symbol_511)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_512, sizeof(symbol_512)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_513, sizeof(symbol_513)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_514, sizeof(symbol_514)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_515, sizeof(symbol_515)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_516, sizeof(symbol_516)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_517, sizeof(symbol_517)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_478, sizeof(symbol_478)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_479, sizeof(symbol_479)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_480, sizeof(symbol_480)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_481, sizeof(symbol_481)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_482, sizeof(symbol_482)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_483, sizeof(symbol_483)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_484, sizeof(symbol_484)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_485, sizeof(symbol_485)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_486, sizeof(symbol_486)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_487, sizeof(symbol_487)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_488, sizeof(symbol_488)-1), 0, NULL);
 }
 
 void action_29(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_29\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_521, sizeof(symbol_521)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_522, sizeof(symbol_522)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_523, sizeof(symbol_523)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_492, sizeof(symbol_492)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_493, sizeof(symbol_493)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_494, sizeof(symbol_494)-1), 0, NULL);
 }
 
 void action_30(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_30\n");
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_namedChunks;
     runtime->current_chunks = chunks;
-    action = lookup_action(variables, buffer_from_cstring(symbol_525, sizeof(symbol_525)-1));
+    action = lookup_action(variables, buffer_from_cstring(symbol_496, sizeof(symbol_496)-1));
     if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_526, sizeof(symbol_526)-1), 0, NULL);
-        run_action(lookup_action(variables, buffer_from_cstring(symbol_527, sizeof(symbol_527)-1)), runtime);
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_528, sizeof(symbol_528)-1), 0, NULL);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_497, sizeof(symbol_497)-1), 0, NULL);
+        run_action(lookup_action(variables, buffer_from_cstring(symbol_498, sizeof(symbol_498)-1)), runtime);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_499, sizeof(symbol_499)-1), 0, NULL);
     }
     runtime->current_chunks = last_chunks;
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_529, sizeof(symbol_529)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_500, sizeof(symbol_500)-1)), runtime);
 }
 
 void action_31(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_31\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_531, sizeof(symbol_531)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_502, sizeof(symbol_502)-1)), runtime);
 }
 
 void action_32(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_32\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_547, sizeof(symbol_547)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_548, sizeof(symbol_548)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_549, sizeof(symbol_549)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_518, sizeof(symbol_518)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_519, sizeof(symbol_519)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_520, sizeof(symbol_520)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_550, sizeof(symbol_550)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_551, sizeof(symbol_551)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_552, sizeof(symbol_552)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_521, sizeof(symbol_521)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_522, sizeof(symbol_522)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_523, sizeof(symbol_523)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_553, sizeof(symbol_553)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_524, sizeof(symbol_524)-1), 0, NULL);
 }
 
 void action_33(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_33\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_555, sizeof(symbol_555)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_556, sizeof(symbol_556)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_557, sizeof(symbol_557)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_558, sizeof(symbol_558)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_559, sizeof(symbol_559)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_526, sizeof(symbol_526)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_527, sizeof(symbol_527)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_528, sizeof(symbol_528)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_529, sizeof(symbol_529)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_530, sizeof(symbol_530)-1), 0, NULL);
 }
 
 void action_34(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_34\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_565, sizeof(symbol_565)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_566, sizeof(symbol_566)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_567, sizeof(symbol_567)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_568, sizeof(symbol_568)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_569, sizeof(symbol_569)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_570, sizeof(symbol_570)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_571, sizeof(symbol_571)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_536, sizeof(symbol_536)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_537, sizeof(symbol_537)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_538, sizeof(symbol_538)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_539, sizeof(symbol_539)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_540, sizeof(symbol_540)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_541, sizeof(symbol_541)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_542, sizeof(symbol_542)-1), 0, NULL);
 }
 
 void action_35(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_35\n");
     runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_575, sizeof(symbol_575)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_546, sizeof(symbol_546)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_576, sizeof(symbol_576)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_577, sizeof(symbol_577)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_578, sizeof(symbol_578)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_547, sizeof(symbol_547)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_548, sizeof(symbol_548)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_549, sizeof(symbol_549)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_579, sizeof(symbol_579)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_550, sizeof(symbol_550)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_580, sizeof(symbol_580)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_551, sizeof(symbol_551)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_581, sizeof(symbol_581)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_552, sizeof(symbol_552)-1), 0, NULL);
 }
 
 void action_36(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_36\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_584, sizeof(symbol_584)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_585, sizeof(symbol_585)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_586, sizeof(symbol_586)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_587, sizeof(symbol_587)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_555, sizeof(symbol_555)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_556, sizeof(symbol_556)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_557, sizeof(symbol_557)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_558, sizeof(symbol_558)-1)), runtime);
 }
 
 void action_37(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_37\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_590, sizeof(symbol_590)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_591, sizeof(symbol_591)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_561, sizeof(symbol_561)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_562, sizeof(symbol_562)-1)), runtime);
 }
 
 void action_38(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_38\n");
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_namedWs;
     runtime->current_chunks = chunks;
-    action = lookup_action(variables, buffer_from_cstring(symbol_595, sizeof(symbol_595)-1));
+    action = lookup_action(variables, buffer_from_cstring(symbol_566, sizeof(symbol_566)-1));
     if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_596, sizeof(symbol_596)-1), 0, NULL);
-        run_action(lookup_action(variables, buffer_from_cstring(symbol_597, sizeof(symbol_597)-1)), runtime);
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_598, sizeof(symbol_598)-1), 0, NULL);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_567, sizeof(symbol_567)-1), 0, NULL);
+        run_action(lookup_action(variables, buffer_from_cstring(symbol_568, sizeof(symbol_568)-1)), runtime);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_569, sizeof(symbol_569)-1), 0, NULL);
     }
     runtime->current_chunks = last_chunks;
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_599, sizeof(symbol_599)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_570, sizeof(symbol_570)-1)), runtime);
 }
 
 void action_39(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_39\n");
     runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_603, sizeof(symbol_603)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_574, sizeof(symbol_574)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_604, sizeof(symbol_604)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_605, sizeof(symbol_605)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_606, sizeof(symbol_606)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_575, sizeof(symbol_575)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_576, sizeof(symbol_576)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_577, sizeof(symbol_577)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_607, sizeof(symbol_607)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_578, sizeof(symbol_578)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_608, sizeof(symbol_608)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_579, sizeof(symbol_579)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_609, sizeof(symbol_609)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_580, sizeof(symbol_580)-1), 0, NULL);
 }
 
 void action_40(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_40\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_613, sizeof(symbol_613)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_584, sizeof(symbol_584)-1), 0, NULL);
 }
 
 void action_41(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_41\n");
     runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_615, sizeof(symbol_615)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_586, sizeof(symbol_586)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_616, sizeof(symbol_616)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_617, sizeof(symbol_617)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_618, sizeof(symbol_618)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_587, sizeof(symbol_587)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_588, sizeof(symbol_588)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_589, sizeof(symbol_589)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_619, sizeof(symbol_619)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_590, sizeof(symbol_590)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_620, sizeof(symbol_620)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_591, sizeof(symbol_591)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_621, sizeof(symbol_621)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_592, sizeof(symbol_592)-1), 0, NULL);
 }
 
 struct Action* rule_main(struct ParseState* parse_state) {
@@ -2045,7 +1925,6 @@ struct Action* rule_main(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule main [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -2055,7 +1934,6 @@ struct Action* rule_main(struct ParseState* parse_state) {
     if (_) {
         return create_action(action_1, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail main [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2069,7 +1947,6 @@ struct Action* rule_file(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule file [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -2085,7 +1962,6 @@ struct Action* rule_file(struct ParseState* parse_state) {
         }
         append_named_action(star_variables, NULL, _);
     }
-    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
     _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
     append_named_action(variables, buffer_from_cstring(symbol_3, sizeof(symbol_3)-1), _);
     if (_) {
@@ -2109,7 +1985,6 @@ struct Action* rule_file(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail file [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2123,7 +1998,6 @@ struct Action* rule_rule(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule rule [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -2131,11 +2005,11 @@ struct Action* rule_rule(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_name(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_322, sizeof(symbol_322)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_302, sizeof(symbol_302)-1), _);
         if (_) {
             _ = rule_space(parse_state);
             if (_) {
-                data = buffer_from_cstring(symbol_323, sizeof(symbol_323)-1);
+                data = buffer_from_cstring(symbol_303, sizeof(symbol_303)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2146,11 +2020,11 @@ struct Action* rule_rule(struct ParseState* parse_state) {
                     _ = rule_space(parse_state);
                     if (_) {
                         _ = rule_ors(parse_state);
-                        append_named_action(variables, buffer_from_cstring(symbol_324, sizeof(symbol_324)-1), _);
+                        append_named_action(variables, buffer_from_cstring(symbol_304, sizeof(symbol_304)-1), _);
                         if (_) {
                             _ = rule_space(parse_state);
                             if (_) {
-                                data = buffer_from_cstring(symbol_325, sizeof(symbol_325)-1);
+                                data = buffer_from_cstring(symbol_305, sizeof(symbol_305)-1);
                                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                     parse_state->pos += data->size;
                                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2167,7 +2041,6 @@ struct Action* rule_rule(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail rule [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2181,7 +2054,6 @@ struct Action* rule_ors(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule ors [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -2189,7 +2061,7 @@ struct Action* rule_ors(struct ParseState* parse_state) {
     _ = rule_maybeorbar(parse_state);
     if (_) {
         _ = rule_orcase(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_351, sizeof(symbol_351)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_325, sizeof(symbol_325)-1), _);
         if (_) {
             star_variables = create_variables();
             star_start_pos = parse_state->pos;
@@ -2202,15 +2074,13 @@ struct Action* rule_ors(struct ParseState* parse_state) {
                 }
                 append_named_action(star_variables, NULL, _);
             }
-            fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
             _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-            append_named_action(variables, buffer_from_cstring(symbol_352, sizeof(symbol_352)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_326, sizeof(symbol_326)-1), _);
             if (_) {
                 return create_action(action_4, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
         }
     }
-    fprintf(stderr, "debug: rule fail ors [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2224,7 +2094,6 @@ struct Action* rule_restorcase(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule restorcase [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -2232,12 +2101,11 @@ struct Action* rule_restorcase(struct ParseState* parse_state) {
     _ = rule_orbar(parse_state);
     if (_) {
         _ = rule_orcase(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_356, sizeof(symbol_356)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_330, sizeof(symbol_330)-1), _);
         if (_) {
             return create_action(action_5, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail restorcase [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2251,7 +2119,6 @@ struct Action* rule_maybeorbar(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule maybeorbar [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -2264,7 +2131,6 @@ struct Action* rule_maybeorbar(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     return create_action(action_6, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
-    fprintf(stderr, "debug: rule fail maybeorbar [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2278,14 +2144,13 @@ struct Action* rule_orbar(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule orbar [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_358, sizeof(symbol_358)-1);
+        data = buffer_from_cstring(symbol_332, sizeof(symbol_332)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2296,7 +2161,6 @@ struct Action* rule_orbar(struct ParseState* parse_state) {
             return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail orbar [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2310,17 +2174,15 @@ struct Action* rule_orcase(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule orcase [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchAnd(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_359, sizeof(symbol_359)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_333, sizeof(symbol_333)-1), _);
     if (_) {
         return create_action(action_7, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail orcase [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2334,7 +2196,6 @@ struct Action* rule_matchAnd(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule matchAnd [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -2342,10 +2203,10 @@ struct Action* rule_matchAnd(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_matchExpr(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_364, sizeof(symbol_364)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_338, sizeof(symbol_338)-1), _);
         if (_) {
             _ = rule_matchAnd(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_365, sizeof(symbol_365)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_339, sizeof(symbol_339)-1), _);
             if (_) {
                 return create_action(action_8, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
@@ -2355,11 +2216,10 @@ struct Action* rule_matchAnd(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_action(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_370, sizeof(symbol_370)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_344, sizeof(symbol_344)-1), _);
     if (_) {
         return create_action(action_9, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail matchAnd [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2373,12 +2233,11 @@ struct Action* rule_matchExpr(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule matchExpr [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_372, sizeof(symbol_372)-1);
+    data = buffer_from_cstring(symbol_346, sizeof(symbol_346)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2387,7 +2246,7 @@ struct Action* rule_matchExpr(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_matchExprPrimitive(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_373, sizeof(symbol_373)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_347, sizeof(symbol_347)-1), _);
         if (_) {
             return create_action(action_10, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2396,15 +2255,14 @@ struct Action* rule_matchExpr(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchExprRepeat(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_382, sizeof(symbol_382)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_356, sizeof(symbol_356)-1), _);
     if (_) {
         _ = rule_matchAssign(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_383, sizeof(symbol_383)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_357, sizeof(symbol_357)-1), _);
         if (_) {
             return create_action(action_11, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail matchExpr [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2418,12 +2276,11 @@ struct Action* rule_matchAssign(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule matchAssign [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_386, sizeof(symbol_386)-1);
+    data = buffer_from_cstring(symbol_360, sizeof(symbol_360)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2432,7 +2289,7 @@ struct Action* rule_matchAssign(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_nameAsSymbol(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_387, sizeof(symbol_387)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_361, sizeof(symbol_361)-1), _);
         if (_) {
             return create_action(action_12, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2441,7 +2298,6 @@ struct Action* rule_matchAssign(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     return create_action(action_13, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
-    fprintf(stderr, "debug: rule fail matchAssign [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2455,15 +2311,14 @@ struct Action* rule_matchExprRepeat(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule matchExprRepeat [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchExprPrimitive(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_391, sizeof(symbol_391)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_365, sizeof(symbol_365)-1), _);
     if (_) {
-        data = buffer_from_cstring(symbol_392, sizeof(symbol_392)-1);
+        data = buffer_from_cstring(symbol_366, sizeof(symbol_366)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2478,11 +2333,10 @@ struct Action* rule_matchExprRepeat(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchExprPrimitive(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_406, sizeof(symbol_406)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_379, sizeof(symbol_379)-1), _);
     if (_) {
         return create_action(action_15, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail matchExprRepeat [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2496,20 +2350,19 @@ struct Action* rule_matchExprPrimitive(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule matchExprPrimitive [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_name(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_408, sizeof(symbol_408)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_381, sizeof(symbol_381)-1), _);
     if (_) {
         return create_action(action_16, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_412, sizeof(symbol_412)-1);
+    data = buffer_from_cstring(symbol_385, sizeof(symbol_385)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2523,11 +2376,10 @@ struct Action* rule_matchExprPrimitive(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_charstring(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_419, sizeof(symbol_419)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_392, sizeof(symbol_392)-1), _);
     if (_) {
         return create_action(action_18, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail matchExprPrimitive [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2541,14 +2393,13 @@ struct Action* rule_action(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule action [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_429, sizeof(symbol_429)-1);
+        data = buffer_from_cstring(symbol_402, sizeof(symbol_402)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2558,7 +2409,7 @@ struct Action* rule_action(struct ParseState* parse_state) {
         if (_) {
             _ = rule_space(parse_state);
             if (_) {
-                data = buffer_from_cstring(symbol_430, sizeof(symbol_430)-1);
+                data = buffer_from_cstring(symbol_403, sizeof(symbol_403)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2577,13 +2428,12 @@ struct Action* rule_action(struct ParseState* parse_state) {
                         }
                         append_named_action(star_variables, NULL, _);
                     }
-                    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
                     _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-                    append_named_action(variables, buffer_from_cstring(symbol_431, sizeof(symbol_431)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_404, sizeof(symbol_404)-1), _);
                     if (_) {
                         _ = rule_space(parse_state);
                         if (_) {
-                            data = buffer_from_cstring(symbol_432, sizeof(symbol_432)-1);
+                            data = buffer_from_cstring(symbol_405, sizeof(symbol_405)-1);
                             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                 parse_state->pos += data->size;
                                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2603,7 +2453,6 @@ struct Action* rule_action(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     return create_action(action_20, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
-    fprintf(stderr, "debug: rule fail action [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2617,14 +2466,13 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule actionexpr [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_446, sizeof(symbol_446)-1);
+        data = buffer_from_cstring(symbol_417, sizeof(symbol_417)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2633,9 +2481,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_nameAsSymbol(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_447, sizeof(symbol_447)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_418, sizeof(symbol_418)-1), _);
             if (_) {
-                data = buffer_from_cstring(symbol_448, sizeof(symbol_448)-1);
+                data = buffer_from_cstring(symbol_419, sizeof(symbol_419)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2654,13 +2502,12 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                         }
                         append_named_action(star_variables, NULL, _);
                     }
-                    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
                     _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-                    append_named_action(variables, buffer_from_cstring(symbol_449, sizeof(symbol_449)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_420, sizeof(symbol_420)-1), _);
                     if (_) {
                         _ = rule_space(parse_state);
                         if (_) {
-                            data = buffer_from_cstring(symbol_450, sizeof(symbol_450)-1);
+                            data = buffer_from_cstring(symbol_421, sizeof(symbol_421)-1);
                             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                 parse_state->pos += data->size;
                                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2681,7 +2528,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_457, sizeof(symbol_457)-1);
+        data = buffer_from_cstring(symbol_428, sizeof(symbol_428)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2690,11 +2537,11 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_chunkName(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_458, sizeof(symbol_458)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_429, sizeof(symbol_429)-1), _);
             if (_) {
                 _ = rule_space(parse_state);
                 if (_) {
-                    data = buffer_from_cstring(symbol_459, sizeof(symbol_459)-1);
+                    data = buffer_from_cstring(symbol_430, sizeof(symbol_430)-1);
                     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                         parse_state->pos += data->size;
                         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2713,13 +2560,12 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                             }
                             append_named_action(star_variables, NULL, _);
                         }
-                        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
                         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-                        append_named_action(variables, buffer_from_cstring(symbol_460, sizeof(symbol_460)-1), _);
+                        append_named_action(variables, buffer_from_cstring(symbol_431, sizeof(symbol_431)-1), _);
                         if (_) {
                             _ = rule_space(parse_state);
                             if (_) {
-                                data = buffer_from_cstring(symbol_461, sizeof(symbol_461)-1);
+                                data = buffer_from_cstring(symbol_432, sizeof(symbol_432)-1);
                                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                     parse_state->pos += data->size;
                                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2741,7 +2587,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_469, sizeof(symbol_469)-1);
+        data = buffer_from_cstring(symbol_440, sizeof(symbol_440)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2750,7 +2596,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_chunkName(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_470, sizeof(symbol_470)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_441, sizeof(symbol_441)-1), _);
             if (_) {
                 return create_action(action_23, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
@@ -2762,7 +2608,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_expr(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_476, sizeof(symbol_476)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_447, sizeof(symbol_447)-1), _);
         if (_) {
             return create_action(action_24, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2773,7 +2619,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_nameAsSymbol(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_480, sizeof(symbol_480)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_451, sizeof(symbol_451)-1), _);
         if (_) {
             return create_action(action_25, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2784,7 +2630,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_placeholder(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_484, sizeof(symbol_484)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_455, sizeof(symbol_455)-1), _);
         if (_) {
             return create_action(action_26, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2795,7 +2641,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_string(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_496, sizeof(symbol_496)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_467, sizeof(symbol_467)-1), _);
         if (_) {
             return create_action(action_27, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2805,7 +2651,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_500, sizeof(symbol_500)-1);
+        data = buffer_from_cstring(symbol_471, sizeof(symbol_471)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2814,9 +2660,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_name(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_501, sizeof(symbol_501)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_472, sizeof(symbol_472)-1), _);
             if (_) {
-                data = buffer_from_cstring(symbol_502, sizeof(symbol_502)-1);
+                data = buffer_from_cstring(symbol_473, sizeof(symbol_473)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2825,9 +2671,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                 }
                 if (_) {
                     _ = rule_wvar(parse_state);
-                    append_named_action(variables, buffer_from_cstring(symbol_503, sizeof(symbol_503)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_474, sizeof(symbol_474)-1), _);
                     if (_) {
-                        data = buffer_from_cstring(symbol_504, sizeof(symbol_504)-1);
+                        data = buffer_from_cstring(symbol_475, sizeof(symbol_475)-1);
                         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                             parse_state->pos += data->size;
                             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2836,9 +2682,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                         }
                         if (_) {
                             _ = rule_actionPrimitiveExpression(parse_state);
-                            append_named_action(variables, buffer_from_cstring(symbol_505, sizeof(symbol_505)-1), _);
+                            append_named_action(variables, buffer_from_cstring(symbol_476, sizeof(symbol_476)-1), _);
                             if (_) {
-                                data = buffer_from_cstring(symbol_506, sizeof(symbol_506)-1);
+                                data = buffer_from_cstring(symbol_477, sizeof(symbol_477)-1);
                                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                     parse_state->pos += data->size;
                                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2860,7 +2706,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_518, sizeof(symbol_518)-1);
+        data = buffer_from_cstring(symbol_489, sizeof(symbol_489)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2879,13 +2725,12 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                 }
                 append_named_action(star_variables, NULL, _);
             }
-            fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
             _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-            append_named_action(variables, buffer_from_cstring(symbol_519, sizeof(symbol_519)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_490, sizeof(symbol_490)-1), _);
             if (_) {
                 _ = rule_space(parse_state);
                 if (_) {
-                    data = buffer_from_cstring(symbol_520, sizeof(symbol_520)-1);
+                    data = buffer_from_cstring(symbol_491, sizeof(symbol_491)-1);
                     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                         parse_state->pos += data->size;
                         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2899,7 +2744,6 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail actionexpr [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2913,17 +2757,15 @@ struct Action* rule_chunkName(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule chunkName [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_name(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_524, sizeof(symbol_524)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_495, sizeof(symbol_495)-1), _);
     if (_) {
         return create_action(action_30, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail chunkName [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2937,13 +2779,12 @@ struct Action* rule_actionPrimitiveExpression(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule actionPrimitiveExpression [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_dotname(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_530, sizeof(symbol_530)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_501, sizeof(symbol_501)-1), _);
     if (_) {
         return create_action(action_31, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -2954,7 +2795,6 @@ struct Action* rule_actionPrimitiveExpression(struct ParseState* parse_state) {
     if (_) {
         return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail actionPrimitiveExpression [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -2968,12 +2808,11 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule digit [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_532, sizeof(symbol_532)-1);
+    data = buffer_from_cstring(symbol_503, sizeof(symbol_503)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2986,7 +2825,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_533, sizeof(symbol_533)-1);
+    data = buffer_from_cstring(symbol_504, sizeof(symbol_504)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2999,7 +2838,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_534, sizeof(symbol_534)-1);
+    data = buffer_from_cstring(symbol_505, sizeof(symbol_505)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3012,7 +2851,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_535, sizeof(symbol_535)-1);
+    data = buffer_from_cstring(symbol_506, sizeof(symbol_506)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3025,7 +2864,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_536, sizeof(symbol_536)-1);
+    data = buffer_from_cstring(symbol_507, sizeof(symbol_507)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3038,7 +2877,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_537, sizeof(symbol_537)-1);
+    data = buffer_from_cstring(symbol_508, sizeof(symbol_508)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3051,7 +2890,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_538, sizeof(symbol_538)-1);
+    data = buffer_from_cstring(symbol_509, sizeof(symbol_509)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3064,7 +2903,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_539, sizeof(symbol_539)-1);
+    data = buffer_from_cstring(symbol_510, sizeof(symbol_510)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3077,7 +2916,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_540, sizeof(symbol_540)-1);
+    data = buffer_from_cstring(symbol_511, sizeof(symbol_511)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3090,7 +2929,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_541, sizeof(symbol_541)-1);
+    data = buffer_from_cstring(symbol_512, sizeof(symbol_512)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3100,7 +2939,6 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     if (_) {
         return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail digit [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3114,12 +2952,11 @@ struct Action* rule_placeholder(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule placeholder [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_542, sizeof(symbol_542)-1);
+    data = buffer_from_cstring(symbol_513, sizeof(symbol_513)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3130,9 +2967,9 @@ struct Action* rule_placeholder(struct ParseState* parse_state) {
         _ = rule_space(parse_state);
         if (_) {
             _ = rule_string(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_543, sizeof(symbol_543)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_514, sizeof(symbol_514)-1), _);
             if (_) {
-                data = buffer_from_cstring(symbol_544, sizeof(symbol_544)-1);
+                data = buffer_from_cstring(symbol_515, sizeof(symbol_515)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3141,11 +2978,11 @@ struct Action* rule_placeholder(struct ParseState* parse_state) {
                 }
                 if (_) {
                     _ = rule_expr(parse_state);
-                    append_named_action(variables, buffer_from_cstring(symbol_545, sizeof(symbol_545)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_516, sizeof(symbol_516)-1), _);
                     if (_) {
                         _ = rule_space(parse_state);
                         if (_) {
-                            data = buffer_from_cstring(symbol_546, sizeof(symbol_546)-1);
+                            data = buffer_from_cstring(symbol_517, sizeof(symbol_517)-1);
                             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                 parse_state->pos += data->size;
                                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3161,7 +2998,6 @@ struct Action* rule_placeholder(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail placeholder [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3175,20 +3011,19 @@ struct Action* rule_expr(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule expr [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_wvar(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_554, sizeof(symbol_554)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_525, sizeof(symbol_525)-1), _);
     if (_) {
         return create_action(action_33, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_560, sizeof(symbol_560)-1);
+    data = buffer_from_cstring(symbol_531, sizeof(symbol_531)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3197,9 +3032,9 @@ struct Action* rule_expr(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_wvar(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_561, sizeof(symbol_561)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_532, sizeof(symbol_532)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_562, sizeof(symbol_562)-1);
+            data = buffer_from_cstring(symbol_533, sizeof(symbol_533)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3208,9 +3043,9 @@ struct Action* rule_expr(struct ParseState* parse_state) {
             }
             if (_) {
                 _ = rule_dotname(parse_state);
-                append_named_action(variables, buffer_from_cstring(symbol_563, sizeof(symbol_563)-1), _);
+                append_named_action(variables, buffer_from_cstring(symbol_534, sizeof(symbol_534)-1), _);
                 if (_) {
-                    data = buffer_from_cstring(symbol_564, sizeof(symbol_564)-1);
+                    data = buffer_from_cstring(symbol_535, sizeof(symbol_535)-1);
                     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                         parse_state->pos += data->size;
                         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3224,7 +3059,6 @@ struct Action* rule_expr(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail expr [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3238,12 +3072,11 @@ struct Action* rule_string(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule string [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_572, sizeof(symbol_572)-1);
+    data = buffer_from_cstring(symbol_543, sizeof(symbol_543)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3262,11 +3095,10 @@ struct Action* rule_string(struct ParseState* parse_state) {
             }
             append_named_action(star_variables, NULL, _);
         }
-        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_573, sizeof(symbol_573)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_544, sizeof(symbol_544)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_574, sizeof(symbol_574)-1);
+            data = buffer_from_cstring(symbol_545, sizeof(symbol_545)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3278,7 +3110,6 @@ struct Action* rule_string(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail string [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3292,13 +3123,12 @@ struct Action* rule_dotname(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule dotname [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_nameAsSymbol(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_582, sizeof(symbol_582)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_553, sizeof(symbol_553)-1), _);
     if (_) {
         star_variables = create_variables();
         star_start_pos = parse_state->pos;
@@ -3311,14 +3141,12 @@ struct Action* rule_dotname(struct ParseState* parse_state) {
             }
             append_named_action(star_variables, NULL, _);
         }
-        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_583, sizeof(symbol_583)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_554, sizeof(symbol_554)-1), _);
         if (_) {
             return create_action(action_36, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail dotname [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3332,12 +3160,11 @@ struct Action* rule_nextname(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule nextname [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_588, sizeof(symbol_588)-1);
+    data = buffer_from_cstring(symbol_559, sizeof(symbol_559)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3346,12 +3173,11 @@ struct Action* rule_nextname(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_name(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_589, sizeof(symbol_589)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_560, sizeof(symbol_560)-1), _);
         if (_) {
             return create_action(action_37, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail nextname [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3365,12 +3191,11 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule wvar [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_592, sizeof(symbol_592)-1);
+    data = buffer_from_cstring(symbol_563, sizeof(symbol_563)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3384,9 +3209,9 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
         } else {
             _ = NULL;
         }
-        append_named_action(variables, buffer_from_cstring(symbol_593, sizeof(symbol_593)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_564, sizeof(symbol_564)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_594, sizeof(symbol_594)-1);
+            data = buffer_from_cstring(symbol_565, sizeof(symbol_565)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3398,7 +3223,6 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail wvar [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3412,12 +3236,11 @@ struct Action* rule_stringinner(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule stringinner [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_600, sizeof(symbol_600)-1);
+    data = buffer_from_cstring(symbol_571, sizeof(symbol_571)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3449,7 +3272,6 @@ struct Action* rule_stringinner(struct ParseState* parse_state) {
             return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail stringinner [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3463,12 +3285,11 @@ struct Action* rule_stringend(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule stringend [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_601, sizeof(symbol_601)-1);
+    data = buffer_from_cstring(symbol_572, sizeof(symbol_572)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3478,7 +3299,6 @@ struct Action* rule_stringend(struct ParseState* parse_state) {
     if (_) {
         return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail stringend [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3492,7 +3312,6 @@ struct Action* rule_charstring(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule charstring [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -3510,9 +3329,8 @@ struct Action* rule_charstring(struct ParseState* parse_state) {
             }
             append_named_action(star_variables, NULL, _);
         }
-        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_602, sizeof(symbol_602)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_573, sizeof(symbol_573)-1), _);
         if (_) {
             _ = rule_quote(parse_state);
             if (_) {
@@ -3520,7 +3338,6 @@ struct Action* rule_charstring(struct ParseState* parse_state) {
             }
         }
     }
-    fprintf(stderr, "debug: rule fail charstring [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3534,12 +3351,11 @@ struct Action* rule_quote(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule quote [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_610, sizeof(symbol_610)-1);
+    data = buffer_from_cstring(symbol_581, sizeof(symbol_581)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3549,7 +3365,6 @@ struct Action* rule_quote(struct ParseState* parse_state) {
     if (_) {
         return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail quote [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3563,12 +3378,11 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule innercharstring [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_611, sizeof(symbol_611)-1);
+    data = buffer_from_cstring(symbol_582, sizeof(symbol_582)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3581,7 +3395,7 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_612, sizeof(symbol_612)-1);
+    data = buffer_from_cstring(symbol_583, sizeof(symbol_583)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3613,7 +3427,6 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
             return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail innercharstring [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3627,17 +3440,15 @@ struct Action* rule_nameAsSymbol(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule nameAsSymbol [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_name(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_614, sizeof(symbol_614)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_585, sizeof(symbol_585)-1), _);
     if (_) {
         return create_action(action_41, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail nameAsSymbol [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3651,7 +3462,6 @@ struct Action* rule_name(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule name [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -3669,13 +3479,11 @@ struct Action* rule_name(struct ParseState* parse_state) {
             }
             append_named_action(star_variables, NULL, _);
         }
-        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
         if (_) {
             return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
-    fprintf(stderr, "debug: rule fail name [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -3689,12 +3497,11 @@ struct Action* rule_char(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule char [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_622, sizeof(symbol_622)-1);
+    data = buffer_from_cstring(symbol_593, sizeof(symbol_593)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3707,7 +3514,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_623, sizeof(symbol_623)-1);
+    data = buffer_from_cstring(symbol_594, sizeof(symbol_594)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3720,7 +3527,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_624, sizeof(symbol_624)-1);
+    data = buffer_from_cstring(symbol_595, sizeof(symbol_595)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3733,7 +3540,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_625, sizeof(symbol_625)-1);
+    data = buffer_from_cstring(symbol_596, sizeof(symbol_596)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3746,7 +3553,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_626, sizeof(symbol_626)-1);
+    data = buffer_from_cstring(symbol_597, sizeof(symbol_597)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3759,7 +3566,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_627, sizeof(symbol_627)-1);
+    data = buffer_from_cstring(symbol_598, sizeof(symbol_598)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3772,7 +3579,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_628, sizeof(symbol_628)-1);
+    data = buffer_from_cstring(symbol_599, sizeof(symbol_599)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3785,7 +3592,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_629, sizeof(symbol_629)-1);
+    data = buffer_from_cstring(symbol_600, sizeof(symbol_600)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3798,7 +3605,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_630, sizeof(symbol_630)-1);
+    data = buffer_from_cstring(symbol_601, sizeof(symbol_601)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3811,7 +3618,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_631, sizeof(symbol_631)-1);
+    data = buffer_from_cstring(symbol_602, sizeof(symbol_602)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3824,7 +3631,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_632, sizeof(symbol_632)-1);
+    data = buffer_from_cstring(symbol_603, sizeof(symbol_603)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3837,7 +3644,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_633, sizeof(symbol_633)-1);
+    data = buffer_from_cstring(symbol_604, sizeof(symbol_604)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3850,7 +3657,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_634, sizeof(symbol_634)-1);
+    data = buffer_from_cstring(symbol_605, sizeof(symbol_605)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3863,7 +3670,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_635, sizeof(symbol_635)-1);
+    data = buffer_from_cstring(symbol_606, sizeof(symbol_606)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3876,7 +3683,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_636, sizeof(symbol_636)-1);
+    data = buffer_from_cstring(symbol_607, sizeof(symbol_607)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3889,7 +3696,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_637, sizeof(symbol_637)-1);
+    data = buffer_from_cstring(symbol_608, sizeof(symbol_608)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3902,7 +3709,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_638, sizeof(symbol_638)-1);
+    data = buffer_from_cstring(symbol_609, sizeof(symbol_609)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3915,7 +3722,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_639, sizeof(symbol_639)-1);
+    data = buffer_from_cstring(symbol_610, sizeof(symbol_610)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3928,7 +3735,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_640, sizeof(symbol_640)-1);
+    data = buffer_from_cstring(symbol_611, sizeof(symbol_611)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3941,7 +3748,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_641, sizeof(symbol_641)-1);
+    data = buffer_from_cstring(symbol_612, sizeof(symbol_612)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3954,7 +3761,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_642, sizeof(symbol_642)-1);
+    data = buffer_from_cstring(symbol_613, sizeof(symbol_613)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3967,7 +3774,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_643, sizeof(symbol_643)-1);
+    data = buffer_from_cstring(symbol_614, sizeof(symbol_614)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3980,7 +3787,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_644, sizeof(symbol_644)-1);
+    data = buffer_from_cstring(symbol_615, sizeof(symbol_615)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3993,7 +3800,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_645, sizeof(symbol_645)-1);
+    data = buffer_from_cstring(symbol_616, sizeof(symbol_616)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4006,7 +3813,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_646, sizeof(symbol_646)-1);
+    data = buffer_from_cstring(symbol_617, sizeof(symbol_617)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4019,7 +3826,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_647, sizeof(symbol_647)-1);
+    data = buffer_from_cstring(symbol_618, sizeof(symbol_618)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4032,7 +3839,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_648, sizeof(symbol_648)-1);
+    data = buffer_from_cstring(symbol_619, sizeof(symbol_619)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4045,7 +3852,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_649, sizeof(symbol_649)-1);
+    data = buffer_from_cstring(symbol_620, sizeof(symbol_620)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4058,7 +3865,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_650, sizeof(symbol_650)-1);
+    data = buffer_from_cstring(symbol_621, sizeof(symbol_621)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4071,7 +3878,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_651, sizeof(symbol_651)-1);
+    data = buffer_from_cstring(symbol_622, sizeof(symbol_622)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4084,7 +3891,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_652, sizeof(symbol_652)-1);
+    data = buffer_from_cstring(symbol_623, sizeof(symbol_623)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4097,7 +3904,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_653, sizeof(symbol_653)-1);
+    data = buffer_from_cstring(symbol_624, sizeof(symbol_624)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4110,7 +3917,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_654, sizeof(symbol_654)-1);
+    data = buffer_from_cstring(symbol_625, sizeof(symbol_625)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4123,7 +3930,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_655, sizeof(symbol_655)-1);
+    data = buffer_from_cstring(symbol_626, sizeof(symbol_626)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4136,7 +3943,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_656, sizeof(symbol_656)-1);
+    data = buffer_from_cstring(symbol_627, sizeof(symbol_627)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4149,7 +3956,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_657, sizeof(symbol_657)-1);
+    data = buffer_from_cstring(symbol_628, sizeof(symbol_628)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4162,7 +3969,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_658, sizeof(symbol_658)-1);
+    data = buffer_from_cstring(symbol_629, sizeof(symbol_629)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4175,7 +3982,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_659, sizeof(symbol_659)-1);
+    data = buffer_from_cstring(symbol_630, sizeof(symbol_630)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4188,7 +3995,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_660, sizeof(symbol_660)-1);
+    data = buffer_from_cstring(symbol_631, sizeof(symbol_631)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4201,7 +4008,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_661, sizeof(symbol_661)-1);
+    data = buffer_from_cstring(symbol_632, sizeof(symbol_632)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4214,7 +4021,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_662, sizeof(symbol_662)-1);
+    data = buffer_from_cstring(symbol_633, sizeof(symbol_633)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4227,7 +4034,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_663, sizeof(symbol_663)-1);
+    data = buffer_from_cstring(symbol_634, sizeof(symbol_634)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4240,7 +4047,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_664, sizeof(symbol_664)-1);
+    data = buffer_from_cstring(symbol_635, sizeof(symbol_635)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4253,7 +4060,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_665, sizeof(symbol_665)-1);
+    data = buffer_from_cstring(symbol_636, sizeof(symbol_636)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4266,7 +4073,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_666, sizeof(symbol_666)-1);
+    data = buffer_from_cstring(symbol_637, sizeof(symbol_637)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4279,7 +4086,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_667, sizeof(symbol_667)-1);
+    data = buffer_from_cstring(symbol_638, sizeof(symbol_638)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4292,7 +4099,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_668, sizeof(symbol_668)-1);
+    data = buffer_from_cstring(symbol_639, sizeof(symbol_639)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4305,7 +4112,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_669, sizeof(symbol_669)-1);
+    data = buffer_from_cstring(symbol_640, sizeof(symbol_640)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4318,7 +4125,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_670, sizeof(symbol_670)-1);
+    data = buffer_from_cstring(symbol_641, sizeof(symbol_641)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4331,7 +4138,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_671, sizeof(symbol_671)-1);
+    data = buffer_from_cstring(symbol_642, sizeof(symbol_642)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4344,7 +4151,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_672, sizeof(symbol_672)-1);
+    data = buffer_from_cstring(symbol_643, sizeof(symbol_643)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4357,7 +4164,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_673, sizeof(symbol_673)-1);
+    data = buffer_from_cstring(symbol_644, sizeof(symbol_644)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4367,7 +4174,6 @@ struct Action* rule_char(struct ParseState* parse_state) {
     if (_) {
         return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail char [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -4381,7 +4187,6 @@ struct Action* rule_space(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule space [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -4397,12 +4202,10 @@ struct Action* rule_space(struct ParseState* parse_state) {
         }
         append_named_action(star_variables, NULL, _);
     }
-    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
     _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
     if (_) {
         return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail space [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -4416,12 +4219,11 @@ struct Action* rule_spacechar(struct ParseState* parse_state) {
     struct Variables* star_variables;
     struct Action* _;
     struct Buffer* data;
-    fprintf(stderr, "debug: rule spacechar [pos=%d]\n", parse_state->pos);
     or_backtrack_pos = parse_state->pos;
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_674, sizeof(symbol_674)-1);
+    data = buffer_from_cstring(symbol_645, sizeof(symbol_645)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4434,7 +4236,7 @@ struct Action* rule_spacechar(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_675, sizeof(symbol_675)-1);
+    data = buffer_from_cstring(symbol_646, sizeof(symbol_646)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4444,7 +4246,6 @@ struct Action* rule_spacechar(struct ParseState* parse_state) {
     if (_) {
         return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
-    fprintf(stderr, "debug: rule fail spacechar [pos=%d]\n", parse_state->pos);
     return NULL;
 }
 
@@ -4455,7 +4256,6 @@ int main(void) {
     struct ParseState* parse_state = create_parse_state_from_stdin();
     char last_char = '\n';
     int indent = 0;
-    fprintf(stderr, parse_state->input_buffer->buffer);
     struct Runtime* runtime = create_runtime();
     struct Action* action = rule_main(parse_state);
     struct Placeholder* placeholder;
@@ -4470,8 +4270,5 @@ int main(void) {
         run_action(placeholder->action, runtime);
         placeholder = placeholder->next;
     }
-    fprintf(stderr, "debug: arena memory = %p\n", arena);
-    fprintf(stderr, "debug: arena limit  = %u\n", arena_limit);
-    fprintf(stderr, "debug: arena used   = %u\n", arena_pos);
     render_chunks(runtime->main_chunks, &last_char, &indent);
 }
diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 5bebd12..814e36a 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -96,7 +96,6 @@ file = rule*:xs space !. -> {
             "parse_state->input_buffer->size++;\n"
         < "}\n"
         "parse_state->input_buffer->size--;\n"
-        "fprintf(stderr, \"debug: stdin data memory = %p\\n\", parse_state->input_buffer->buffer);\n"
         "return parse_state;\n"
     < "}\n"
     "\n"
@@ -132,7 +131,6 @@ file = rule*:xs space !. -> {
         "action->start = start;\n"
         "action->end = end;\n"
         "action->len = end-start;\n"
-        "fprintf(stderr, \"debug: action [start=%d] [end=%d]\\n\", action->start, action->end);\n"
         "return action;\n"
     < "}\n"
     "\n"
@@ -152,14 +150,6 @@ file = rule*:xs space !. -> {
         "chunk->indentation_delta = indentation_delta;\n"
         "chunks->last->next = chunk;\n"
         "chunks->last = chunk;\n"
-        "fprintf(stderr, \"debug: append chunk = %p\\n\", chunk);\n"
-        "if (chunk->data) {\n" >
-            "fprintf(stderr, \"  data = \");\n"
-            "for (int i=0; i<chunk->data->size; i++) {\n" >
-                "fprintf(stderr, \"%c\", chunk->data->buffer[i]);\n"
-            < "}\n"
-            "fprintf(stderr, \"\\n\");\n"
-        < "}\n"
     < "}\n"
     "\n"
     "struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {\n" >
@@ -190,14 +180,12 @@ file = rule*:xs space !. -> {
             "action->function(runtime, action->variables);\n"
         < "} else {\n" >
             "if (action->variables) {\n" >
-                "fprintf(stderr, \"debug_run_action variables\\n\");\n"
                 "struct Variable* variable = action->variables->pre_first->next;\n"
                 "while (variable) {\n" >
                     "run_action(variable->action, runtime);\n"
                     "variable = variable->next;\n"
                 < "}\n"
             < "} else {\n" >
-                "fprintf(stderr, \"debug_run_action else\\n\");\n"
                 "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n"
             < "}\n"
         < "}\n"
@@ -239,7 +227,6 @@ file = rule*:xs space !. -> {
         "struct Variable* variable = variables->pre_first->next;\n"
         "while (variable) {\n" >
             "if (compare_buffers(variable->name, name_to_look_for)) {\n" >
-                "fprintf(stderr, \"debug: found action %p\\n\", variable->action);\n"
                 "return variable->action;\n"
             < "} else {\n" >
                 "variable = variable->next;\n"
@@ -267,14 +254,11 @@ file = rule*:xs space !. -> {
     < "}\n"
     "\n"
     "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n" >
-        "fprintf(stderr, \"debug: render chunks\\n\");\n"
         "if (chunks) {\n" >
             "struct Chunk* chunk = chunks->pre_first->next;\n"
             "while (chunk) {\n" >
                 "*indent += chunk->indentation_delta;\n"
                 "if (chunk->data) {\n" >
-                    "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n"
-                    "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n"
                     "for (int i=0; i<chunk->data->size; i++) {\n" >
                         "if (*last_char == '\\n') {\n" >
                             "for (int j=0; j<*indent; j++) {\n" >
@@ -305,8 +289,6 @@ file = rule*:xs space !. -> {
         "struct ParseState* parse_state = create_parse_state_from_stdin();\n"
         "char last_char = '\\n';\n"
         "int indent = 0;\n"
-        "fprintf(stderr, parse_state->input_buffer->buffer);\n"
-
         "struct Runtime* runtime = create_runtime();\n"
         "struct Action* action = rule_main(parse_state);\n"
         "struct Placeholder* placeholder;\n"
@@ -321,9 +303,6 @@ file = rule*:xs space !. -> {
             "run_action(placeholder->action, runtime);\n"
             "placeholder = placeholder->next;\n"
         < "}\n"
-        "fprintf(stderr, \"debug: arena memory = %p\\n\", arena);\n"
-        "fprintf(stderr, \"debug: arena limit  = %u\\n\", arena_limit);\n"
-        "fprintf(stderr, \"debug: arena used   = %u\\n\", arena_pos);\n"
         "render_chunks(runtime->main_chunks, &last_char, &indent);\n"
     < "}\n"
 };
@@ -342,9 +321,7 @@ rule = space name:x space '=' space ors:y space ';' -> {
         "struct Variables* star_variables;\n"
         "struct Action* _;\n"
         "struct Buffer* data;\n"
-        "fprintf(stderr, \"debug: rule " x " [pos=%d]\\n\", parse_state->pos);\n"
         y
-        "fprintf(stderr, \"debug: rule fail " x " [pos=%d]\\n\", parse_state->pos);\n"
         "return NULL;\n"
     < "}\n"
     "\n"
@@ -411,7 +388,6 @@ matchExprRepeat =
             < "}\n"
             "append_named_action(star_variables, NULL, _);\n"
         < "}\n"
-        "fprintf(stderr, \"debug: creating_star [%d, %d, %p]\\n\", star_start_pos, parse_state->pos, star_variables->pre_first->next);\n"
         "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n"
     }
     | matchExprPrimitive:x -> {
@@ -450,7 +426,6 @@ action =
                 "struct Chunks* chunks;\n"
                 "struct Chunks* last_chunks;\n"
                 "struct Action* action;\n"
-                "fprintf(stderr, \"debug: running action_" W[0] "\\n\");\n"
                 xs
             < "}\n"
             "\n"

commit c21eb638f59838e2ea713081f811e5857ec6e665
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 12:22:14 2025 +0100

    Fix all things for table

diff --git a/08_translate_to_c/rlmeta2.c b/08_translate_to_c/rlmeta2.c
index 6aaffec..665f354 100644
--- a/08_translate_to_c/rlmeta2.c
+++ b/08_translate_to_c/rlmeta2.c
@@ -841,130 +841,135 @@ static char symbol_543[] = "x";
 static char symbol_544[] = "*";
 static char symbol_545[] = "y";
 static char symbol_546[] = "}";
-static char symbol_547[] = "append_data(runtime->current_chunks, ";
-static char symbol_548[] = "x";
-static char symbol_549[] = "*";
-static char symbol_550[] = "y";
-static char symbol_551[] = ", 0, NULL);\n";
-static char symbol_552[] = "x";
-static char symbol_553[] = "(runtime->W_";
+static char symbol_547[] = "for (int i=0; i < ";
+static char symbol_548[] = "y";
+static char symbol_549[] = "; i++) {\n";
+static char symbol_550[] = "append_data(runtime->current_chunks, ";
+static char symbol_551[] = "x";
+static char symbol_552[] = ", 0, NULL);\n";
+static char symbol_553[] = "}\n";
 static char symbol_554[] = "x";
-static char symbol_555[] = " ? runtime->W_";
+static char symbol_555[] = "(runtime->W_";
 static char symbol_556[] = "x";
-static char symbol_557[] = " : 0)";
-static char symbol_558[] = "(";
-static char symbol_559[] = "x";
-static char symbol_560[] = "-";
-static char symbol_561[] = "y";
-static char symbol_562[] = ")";
-static char symbol_563[] = "((runtime->W_";
-static char symbol_564[] = "x";
-static char symbol_565[] = " ? runtime->W_";
+static char symbol_557[] = " ? runtime->W_";
+static char symbol_558[] = "x";
+static char symbol_559[] = " : 0)";
+static char symbol_560[] = "(";
+static char symbol_561[] = "x";
+static char symbol_562[] = "-";
+static char symbol_563[] = "y";
+static char symbol_564[] = ")";
+static char symbol_565[] = "((runtime->W_";
 static char symbol_566[] = "x";
-static char symbol_567[] = " : 0)-";
-static char symbol_568[] = "y";
-static char symbol_569[] = ")";
-static char symbol_570[] = "\"";
-static char symbol_571[] = "xs";
+static char symbol_567[] = " ? runtime->W_";
+static char symbol_568[] = "x";
+static char symbol_569[] = " : 0)-";
+static char symbol_570[] = "y";
+static char symbol_571[] = ")";
 static char symbol_572[] = "\"";
-static char symbol_573[] = "static char symbol_";
-static char symbol_574[] = "[] = \"";
-static char symbol_575[] = "xs";
-static char symbol_576[] = "\";\n";
-static char symbol_577[] = "buffer_from_cstring(symbol_";
-static char symbol_578[] = ", sizeof(symbol_";
-static char symbol_579[] = ")-1)";
-static char symbol_580[] = "x";
-static char symbol_581[] = "xs";
-static char symbol_582[] = "lookup_action(variables, ";
-static char symbol_583[] = "x";
-static char symbol_584[] = ")";
-static char symbol_585[] = "xs";
-static char symbol_586[] = ".";
-static char symbol_587[] = "W[";
-static char symbol_588[] = "x";
-static char symbol_589[] = "]";
-static char symbol_590[] = "x";
-static char symbol_591[] = "unsigned int W_";
-static char symbol_592[] = "x";
-static char symbol_593[] = ";\n";
-static char symbol_594[] = "x";
-static char symbol_595[] = "\\\"";
-static char symbol_596[] = "\"";
-static char symbol_597[] = "xs";
-static char symbol_598[] = "static char symbol_";
-static char symbol_599[] = "[] = \"";
-static char symbol_600[] = "xs";
-static char symbol_601[] = "\";\n";
-static char symbol_602[] = "buffer_from_cstring(symbol_";
-static char symbol_603[] = ", sizeof(symbol_";
-static char symbol_604[] = ")-1)";
-static char symbol_605[] = "\'";
-static char symbol_606[] = "\\\'";
-static char symbol_607[] = "\"";
-static char symbol_608[] = "\\\"";
-static char symbol_609[] = "x";
-static char symbol_610[] = "static char symbol_";
-static char symbol_611[] = "[] = \"";
-static char symbol_612[] = "x";
-static char symbol_613[] = "\";\n";
-static char symbol_614[] = "buffer_from_cstring(symbol_";
-static char symbol_615[] = ", sizeof(symbol_";
-static char symbol_616[] = ")-1)";
-static char symbol_617[] = "a";
-static char symbol_618[] = "b";
-static char symbol_619[] = "c";
-static char symbol_620[] = "d";
-static char symbol_621[] = "e";
-static char symbol_622[] = "f";
-static char symbol_623[] = "g";
-static char symbol_624[] = "h";
-static char symbol_625[] = "i";
-static char symbol_626[] = "j";
-static char symbol_627[] = "k";
-static char symbol_628[] = "l";
-static char symbol_629[] = "m";
-static char symbol_630[] = "n";
-static char symbol_631[] = "o";
-static char symbol_632[] = "p";
-static char symbol_633[] = "q";
-static char symbol_634[] = "r";
-static char symbol_635[] = "s";
-static char symbol_636[] = "t";
-static char symbol_637[] = "u";
-static char symbol_638[] = "v";
-static char symbol_639[] = "w";
-static char symbol_640[] = "x";
-static char symbol_641[] = "y";
-static char symbol_642[] = "z";
-static char symbol_643[] = "A";
-static char symbol_644[] = "B";
-static char symbol_645[] = "C";
-static char symbol_646[] = "D";
-static char symbol_647[] = "E";
-static char symbol_648[] = "F";
-static char symbol_649[] = "G";
-static char symbol_650[] = "H";
-static char symbol_651[] = "I";
-static char symbol_652[] = "J";
-static char symbol_653[] = "K";
-static char symbol_654[] = "L";
-static char symbol_655[] = "M";
-static char symbol_656[] = "N";
-static char symbol_657[] = "O";
-static char symbol_658[] = "P";
-static char symbol_659[] = "Q";
-static char symbol_660[] = "R";
-static char symbol_661[] = "S";
-static char symbol_662[] = "T";
-static char symbol_663[] = "U";
-static char symbol_664[] = "V";
-static char symbol_665[] = "W";
-static char symbol_666[] = "X";
-static char symbol_667[] = "Y";
-static char symbol_668[] = "Z";
-static char symbol_669[] = " ";
-static char symbol_670[] = "\n";
+static char symbol_573[] = "xs";
+static char symbol_574[] = "\"";
+static char symbol_575[] = "static char symbol_";
+static char symbol_576[] = "[] = \"";
+static char symbol_577[] = "xs";
+static char symbol_578[] = "\";\n";
+static char symbol_579[] = "buffer_from_cstring(symbol_";
+static char symbol_580[] = ", sizeof(symbol_";
+static char symbol_581[] = ")-1)";
+static char symbol_582[] = "x";
+static char symbol_583[] = "xs";
+static char symbol_584[] = "lookup_action(variables, ";
+static char symbol_585[] = "x";
+static char symbol_586[] = ")";
+static char symbol_587[] = "xs";
+static char symbol_588[] = ".";
+static char symbol_589[] = "x";
+static char symbol_590[] = "->";
+static char symbol_591[] = "x";
+static char symbol_592[] = "W[";
+static char symbol_593[] = "x";
+static char symbol_594[] = "]";
+static char symbol_595[] = "x";
+static char symbol_596[] = "unsigned int W_";
+static char symbol_597[] = "x";
+static char symbol_598[] = ";\n";
+static char symbol_599[] = "x";
+static char symbol_600[] = "\\\"";
+static char symbol_601[] = "\"";
+static char symbol_602[] = "xs";
+static char symbol_603[] = "static char symbol_";
+static char symbol_604[] = "[] = \"";
+static char symbol_605[] = "xs";
+static char symbol_606[] = "\";\n";
+static char symbol_607[] = "buffer_from_cstring(symbol_";
+static char symbol_608[] = ", sizeof(symbol_";
+static char symbol_609[] = ")-1)";
+static char symbol_610[] = "\'";
+static char symbol_611[] = "\\\'";
+static char symbol_612[] = "\"";
+static char symbol_613[] = "\\\"";
+static char symbol_614[] = "x";
+static char symbol_615[] = "static char symbol_";
+static char symbol_616[] = "[] = \"";
+static char symbol_617[] = "x";
+static char symbol_618[] = "\";\n";
+static char symbol_619[] = "buffer_from_cstring(symbol_";
+static char symbol_620[] = ", sizeof(symbol_";
+static char symbol_621[] = ")-1)";
+static char symbol_622[] = "a";
+static char symbol_623[] = "b";
+static char symbol_624[] = "c";
+static char symbol_625[] = "d";
+static char symbol_626[] = "e";
+static char symbol_627[] = "f";
+static char symbol_628[] = "g";
+static char symbol_629[] = "h";
+static char symbol_630[] = "i";
+static char symbol_631[] = "j";
+static char symbol_632[] = "k";
+static char symbol_633[] = "l";
+static char symbol_634[] = "m";
+static char symbol_635[] = "n";
+static char symbol_636[] = "o";
+static char symbol_637[] = "p";
+static char symbol_638[] = "q";
+static char symbol_639[] = "r";
+static char symbol_640[] = "s";
+static char symbol_641[] = "t";
+static char symbol_642[] = "u";
+static char symbol_643[] = "v";
+static char symbol_644[] = "w";
+static char symbol_645[] = "x";
+static char symbol_646[] = "y";
+static char symbol_647[] = "z";
+static char symbol_648[] = "A";
+static char symbol_649[] = "B";
+static char symbol_650[] = "C";
+static char symbol_651[] = "D";
+static char symbol_652[] = "E";
+static char symbol_653[] = "F";
+static char symbol_654[] = "G";
+static char symbol_655[] = "H";
+static char symbol_656[] = "I";
+static char symbol_657[] = "J";
+static char symbol_658[] = "K";
+static char symbol_659[] = "L";
+static char symbol_660[] = "M";
+static char symbol_661[] = "N";
+static char symbol_662[] = "O";
+static char symbol_663[] = "P";
+static char symbol_664[] = "Q";
+static char symbol_665[] = "R";
+static char symbol_666[] = "S";
+static char symbol_667[] = "T";
+static char symbol_668[] = "U";
+static char symbol_669[] = "V";
+static char symbol_670[] = "W";
+static char symbol_671[] = "X";
+static char symbol_672[] = "Y";
+static char symbol_673[] = "Z";
+static char symbol_674[] = " ";
+static char symbol_675[] = "\n";
 struct Action* rule_main(struct ParseState* parse_state);
 struct Action* rule_file(struct ParseState* parse_state);
 struct Action* rule_rule(struct ParseState* parse_state);
@@ -1884,8 +1889,12 @@ void action_32(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_547, sizeof(symbol_547)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_548, sizeof(symbol_548)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_549, sizeof(symbol_549)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_550, sizeof(symbol_550)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_551, sizeof(symbol_551)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_550, sizeof(symbol_550)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_551, sizeof(symbol_551)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_552, sizeof(symbol_552)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_553, sizeof(symbol_553)-1), 0, NULL);
 }
 
 void action_33(struct Runtime* runtime, struct Variables* variables) {
@@ -1893,11 +1902,11 @@ void action_33(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_33\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_553, sizeof(symbol_553)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_554, sizeof(symbol_554)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_555, sizeof(symbol_555)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_556, sizeof(symbol_556)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_557, sizeof(symbol_557)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_558, sizeof(symbol_558)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_559, sizeof(symbol_559)-1), 0, NULL);
 }
 
 void action_34(struct Runtime* runtime, struct Variables* variables) {
@@ -1905,13 +1914,13 @@ void action_34(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_34\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_563, sizeof(symbol_563)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_564, sizeof(symbol_564)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_565, sizeof(symbol_565)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_566, sizeof(symbol_566)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_567, sizeof(symbol_567)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_568, sizeof(symbol_568)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_569, sizeof(symbol_569)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_570, sizeof(symbol_570)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_571, sizeof(symbol_571)-1), 0, NULL);
 }
 
 void action_35(struct Runtime* runtime, struct Variables* variables) {
@@ -1923,17 +1932,17 @@ void action_35(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_573, sizeof(symbol_573)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_575, sizeof(symbol_575)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_574, sizeof(symbol_574)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_575, sizeof(symbol_575)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_576, sizeof(symbol_576)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_577, sizeof(symbol_577)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_578, sizeof(symbol_578)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_577, sizeof(symbol_577)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_579, sizeof(symbol_579)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_578, sizeof(symbol_578)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_580, sizeof(symbol_580)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_579, sizeof(symbol_579)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_581, sizeof(symbol_581)-1), 0, NULL);
 }
 
 void action_36(struct Runtime* runtime, struct Variables* variables) {
@@ -1941,10 +1950,10 @@ void action_36(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_36\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_582, sizeof(symbol_582)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_583, sizeof(symbol_583)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_584, sizeof(symbol_584)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_585, sizeof(symbol_585)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_586, sizeof(symbol_586)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_587, sizeof(symbol_587)-1)), runtime);
 }
 
 void action_37(struct Runtime* runtime, struct Variables* variables) {
@@ -1952,69 +1961,78 @@ void action_37(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_37\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_590, sizeof(symbol_590)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_591, sizeof(symbol_591)-1)), runtime);
+}
+
+void action_38(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_38\n");
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_namedWs;
     runtime->current_chunks = chunks;
-    action = lookup_action(variables, buffer_from_cstring(symbol_590, sizeof(symbol_590)-1));
+    action = lookup_action(variables, buffer_from_cstring(symbol_595, sizeof(symbol_595)-1));
     if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_591, sizeof(symbol_591)-1), 0, NULL);
-        run_action(lookup_action(variables, buffer_from_cstring(symbol_592, sizeof(symbol_592)-1)), runtime);
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_593, sizeof(symbol_593)-1), 0, NULL);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_596, sizeof(symbol_596)-1), 0, NULL);
+        run_action(lookup_action(variables, buffer_from_cstring(symbol_597, sizeof(symbol_597)-1)), runtime);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_598, sizeof(symbol_598)-1), 0, NULL);
     }
     runtime->current_chunks = last_chunks;
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_594, sizeof(symbol_594)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_599, sizeof(symbol_599)-1)), runtime);
 }
 
-void action_38(struct Runtime* runtime, struct Variables* variables) {
+void action_39(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_38\n");
+    fprintf(stderr, "debug: running action_39\n");
     runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_598, sizeof(symbol_598)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_603, sizeof(symbol_603)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_599, sizeof(symbol_599)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_600, sizeof(symbol_600)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_601, sizeof(symbol_601)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_604, sizeof(symbol_604)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_605, sizeof(symbol_605)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_606, sizeof(symbol_606)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_602, sizeof(symbol_602)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_607, sizeof(symbol_607)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_603, sizeof(symbol_603)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_608, sizeof(symbol_608)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_604, sizeof(symbol_604)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_609, sizeof(symbol_609)-1), 0, NULL);
 }
 
-void action_39(struct Runtime* runtime, struct Variables* variables) {
+void action_40(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_39\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_608, sizeof(symbol_608)-1), 0, NULL);
+    fprintf(stderr, "debug: running action_40\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_613, sizeof(symbol_613)-1), 0, NULL);
 }
 
-void action_40(struct Runtime* runtime, struct Variables* variables) {
+void action_41(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* chunks;
     struct Chunks* last_chunks;
     struct Action* action;
-    fprintf(stderr, "debug: running action_40\n");
+    fprintf(stderr, "debug: running action_41\n");
     runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_610, sizeof(symbol_610)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_615, sizeof(symbol_615)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_611, sizeof(symbol_611)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_612, sizeof(symbol_612)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_613, sizeof(symbol_613)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_616, sizeof(symbol_616)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_617, sizeof(symbol_617)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_618, sizeof(symbol_618)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_614, sizeof(symbol_614)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_619, sizeof(symbol_619)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_615, sizeof(symbol_615)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_620, sizeof(symbol_620)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_616, sizeof(symbol_616)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_621, sizeof(symbol_621)-1), 0, NULL);
 }
 
 struct Action* rule_main(struct ParseState* parse_state) {
@@ -3163,14 +3181,14 @@ struct Action* rule_expr(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_wvar(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_552, sizeof(symbol_552)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_554, sizeof(symbol_554)-1), _);
     if (_) {
         return create_action(action_33, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_558, sizeof(symbol_558)-1);
+    data = buffer_from_cstring(symbol_560, sizeof(symbol_560)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3179,9 +3197,9 @@ struct Action* rule_expr(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_wvar(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_559, sizeof(symbol_559)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_561, sizeof(symbol_561)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_560, sizeof(symbol_560)-1);
+            data = buffer_from_cstring(symbol_562, sizeof(symbol_562)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3190,9 +3208,9 @@ struct Action* rule_expr(struct ParseState* parse_state) {
             }
             if (_) {
                 _ = rule_dotname(parse_state);
-                append_named_action(variables, buffer_from_cstring(symbol_561, sizeof(symbol_561)-1), _);
+                append_named_action(variables, buffer_from_cstring(symbol_563, sizeof(symbol_563)-1), _);
                 if (_) {
-                    data = buffer_from_cstring(symbol_562, sizeof(symbol_562)-1);
+                    data = buffer_from_cstring(symbol_564, sizeof(symbol_564)-1);
                     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                         parse_state->pos += data->size;
                         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3225,7 +3243,7 @@ struct Action* rule_string(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_570, sizeof(symbol_570)-1);
+    data = buffer_from_cstring(symbol_572, sizeof(symbol_572)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3246,9 +3264,9 @@ struct Action* rule_string(struct ParseState* parse_state) {
         }
         fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_571, sizeof(symbol_571)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_573, sizeof(symbol_573)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_572, sizeof(symbol_572)-1);
+            data = buffer_from_cstring(symbol_574, sizeof(symbol_574)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3280,7 +3298,7 @@ struct Action* rule_dotname(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_nameAsSymbol(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_580, sizeof(symbol_580)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_582, sizeof(symbol_582)-1), _);
     if (_) {
         star_variables = create_variables();
         star_start_pos = parse_state->pos;
@@ -3295,7 +3313,7 @@ struct Action* rule_dotname(struct ParseState* parse_state) {
         }
         fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_581, sizeof(symbol_581)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_583, sizeof(symbol_583)-1), _);
         if (_) {
             return create_action(action_36, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -3319,7 +3337,7 @@ struct Action* rule_nextname(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_586, sizeof(symbol_586)-1);
+    data = buffer_from_cstring(symbol_588, sizeof(symbol_588)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3328,8 +3346,9 @@ struct Action* rule_nextname(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_name(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_589, sizeof(symbol_589)-1), _);
         if (_) {
-            return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            return create_action(action_37, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
     }
     fprintf(stderr, "debug: rule fail nextname [pos=%d]\n", parse_state->pos);
@@ -3351,7 +3370,7 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_587, sizeof(symbol_587)-1);
+    data = buffer_from_cstring(symbol_592, sizeof(symbol_592)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3365,9 +3384,9 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
         } else {
             _ = NULL;
         }
-        append_named_action(variables, buffer_from_cstring(symbol_588, sizeof(symbol_588)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_593, sizeof(symbol_593)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_589, sizeof(symbol_589)-1);
+            data = buffer_from_cstring(symbol_594, sizeof(symbol_594)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3375,7 +3394,7 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
                 _ = NULL;
             }
             if (_) {
-                return create_action(action_37, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                return create_action(action_38, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
         }
     }
@@ -3398,7 +3417,7 @@ struct Action* rule_stringinner(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_595, sizeof(symbol_595)-1);
+    data = buffer_from_cstring(symbol_600, sizeof(symbol_600)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3449,7 +3468,7 @@ struct Action* rule_stringend(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_596, sizeof(symbol_596)-1);
+    data = buffer_from_cstring(symbol_601, sizeof(symbol_601)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3493,11 +3512,11 @@ struct Action* rule_charstring(struct ParseState* parse_state) {
         }
         fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_597, sizeof(symbol_597)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_602, sizeof(symbol_602)-1), _);
         if (_) {
             _ = rule_quote(parse_state);
             if (_) {
-                return create_action(action_38, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                return create_action(action_39, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
         }
     }
@@ -3520,7 +3539,7 @@ struct Action* rule_quote(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_605, sizeof(symbol_605)-1);
+    data = buffer_from_cstring(symbol_610, sizeof(symbol_610)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3549,7 +3568,7 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_606, sizeof(symbol_606)-1);
+    data = buffer_from_cstring(symbol_611, sizeof(symbol_611)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3562,7 +3581,7 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_607, sizeof(symbol_607)-1);
+    data = buffer_from_cstring(symbol_612, sizeof(symbol_612)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3570,7 +3589,7 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
         _ = NULL;
     }
     if (_) {
-        return create_action(action_39, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        return create_action(action_40, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
@@ -3614,9 +3633,9 @@ struct Action* rule_nameAsSymbol(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_name(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_609, sizeof(symbol_609)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_614, sizeof(symbol_614)-1), _);
     if (_) {
-        return create_action(action_40, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        return create_action(action_41, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
     fprintf(stderr, "debug: rule fail nameAsSymbol [pos=%d]\n", parse_state->pos);
     return NULL;
@@ -3675,7 +3694,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_617, sizeof(symbol_617)-1);
+    data = buffer_from_cstring(symbol_622, sizeof(symbol_622)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3688,7 +3707,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_618, sizeof(symbol_618)-1);
+    data = buffer_from_cstring(symbol_623, sizeof(symbol_623)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3701,7 +3720,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_619, sizeof(symbol_619)-1);
+    data = buffer_from_cstring(symbol_624, sizeof(symbol_624)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3714,7 +3733,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_620, sizeof(symbol_620)-1);
+    data = buffer_from_cstring(symbol_625, sizeof(symbol_625)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3727,7 +3746,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_621, sizeof(symbol_621)-1);
+    data = buffer_from_cstring(symbol_626, sizeof(symbol_626)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3740,7 +3759,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_622, sizeof(symbol_622)-1);
+    data = buffer_from_cstring(symbol_627, sizeof(symbol_627)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3753,7 +3772,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_623, sizeof(symbol_623)-1);
+    data = buffer_from_cstring(symbol_628, sizeof(symbol_628)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3766,7 +3785,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_624, sizeof(symbol_624)-1);
+    data = buffer_from_cstring(symbol_629, sizeof(symbol_629)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3779,7 +3798,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_625, sizeof(symbol_625)-1);
+    data = buffer_from_cstring(symbol_630, sizeof(symbol_630)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3792,7 +3811,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_626, sizeof(symbol_626)-1);
+    data = buffer_from_cstring(symbol_631, sizeof(symbol_631)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3805,7 +3824,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_627, sizeof(symbol_627)-1);
+    data = buffer_from_cstring(symbol_632, sizeof(symbol_632)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3818,7 +3837,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_628, sizeof(symbol_628)-1);
+    data = buffer_from_cstring(symbol_633, sizeof(symbol_633)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3831,7 +3850,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_629, sizeof(symbol_629)-1);
+    data = buffer_from_cstring(symbol_634, sizeof(symbol_634)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3844,7 +3863,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_630, sizeof(symbol_630)-1);
+    data = buffer_from_cstring(symbol_635, sizeof(symbol_635)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3857,7 +3876,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_631, sizeof(symbol_631)-1);
+    data = buffer_from_cstring(symbol_636, sizeof(symbol_636)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3870,7 +3889,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_632, sizeof(symbol_632)-1);
+    data = buffer_from_cstring(symbol_637, sizeof(symbol_637)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3883,7 +3902,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_633, sizeof(symbol_633)-1);
+    data = buffer_from_cstring(symbol_638, sizeof(symbol_638)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3896,7 +3915,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_634, sizeof(symbol_634)-1);
+    data = buffer_from_cstring(symbol_639, sizeof(symbol_639)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3909,7 +3928,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_635, sizeof(symbol_635)-1);
+    data = buffer_from_cstring(symbol_640, sizeof(symbol_640)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3922,7 +3941,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_636, sizeof(symbol_636)-1);
+    data = buffer_from_cstring(symbol_641, sizeof(symbol_641)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3935,7 +3954,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_637, sizeof(symbol_637)-1);
+    data = buffer_from_cstring(symbol_642, sizeof(symbol_642)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3948,7 +3967,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_638, sizeof(symbol_638)-1);
+    data = buffer_from_cstring(symbol_643, sizeof(symbol_643)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3961,7 +3980,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_639, sizeof(symbol_639)-1);
+    data = buffer_from_cstring(symbol_644, sizeof(symbol_644)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3974,7 +3993,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_640, sizeof(symbol_640)-1);
+    data = buffer_from_cstring(symbol_645, sizeof(symbol_645)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3987,7 +4006,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_641, sizeof(symbol_641)-1);
+    data = buffer_from_cstring(symbol_646, sizeof(symbol_646)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4000,7 +4019,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_642, sizeof(symbol_642)-1);
+    data = buffer_from_cstring(symbol_647, sizeof(symbol_647)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4013,7 +4032,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_643, sizeof(symbol_643)-1);
+    data = buffer_from_cstring(symbol_648, sizeof(symbol_648)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4026,7 +4045,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_644, sizeof(symbol_644)-1);
+    data = buffer_from_cstring(symbol_649, sizeof(symbol_649)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4039,7 +4058,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_645, sizeof(symbol_645)-1);
+    data = buffer_from_cstring(symbol_650, sizeof(symbol_650)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4052,7 +4071,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_646, sizeof(symbol_646)-1);
+    data = buffer_from_cstring(symbol_651, sizeof(symbol_651)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4065,7 +4084,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_647, sizeof(symbol_647)-1);
+    data = buffer_from_cstring(symbol_652, sizeof(symbol_652)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4078,7 +4097,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_648, sizeof(symbol_648)-1);
+    data = buffer_from_cstring(symbol_653, sizeof(symbol_653)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4091,7 +4110,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_649, sizeof(symbol_649)-1);
+    data = buffer_from_cstring(symbol_654, sizeof(symbol_654)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4104,7 +4123,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_650, sizeof(symbol_650)-1);
+    data = buffer_from_cstring(symbol_655, sizeof(symbol_655)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4117,7 +4136,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_651, sizeof(symbol_651)-1);
+    data = buffer_from_cstring(symbol_656, sizeof(symbol_656)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4130,7 +4149,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_652, sizeof(symbol_652)-1);
+    data = buffer_from_cstring(symbol_657, sizeof(symbol_657)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4143,7 +4162,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_653, sizeof(symbol_653)-1);
+    data = buffer_from_cstring(symbol_658, sizeof(symbol_658)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4156,7 +4175,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_654, sizeof(symbol_654)-1);
+    data = buffer_from_cstring(symbol_659, sizeof(symbol_659)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4169,7 +4188,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_655, sizeof(symbol_655)-1);
+    data = buffer_from_cstring(symbol_660, sizeof(symbol_660)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4182,7 +4201,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_656, sizeof(symbol_656)-1);
+    data = buffer_from_cstring(symbol_661, sizeof(symbol_661)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4195,7 +4214,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_657, sizeof(symbol_657)-1);
+    data = buffer_from_cstring(symbol_662, sizeof(symbol_662)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4208,7 +4227,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_658, sizeof(symbol_658)-1);
+    data = buffer_from_cstring(symbol_663, sizeof(symbol_663)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4221,7 +4240,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_659, sizeof(symbol_659)-1);
+    data = buffer_from_cstring(symbol_664, sizeof(symbol_664)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4234,7 +4253,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_660, sizeof(symbol_660)-1);
+    data = buffer_from_cstring(symbol_665, sizeof(symbol_665)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4247,7 +4266,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_661, sizeof(symbol_661)-1);
+    data = buffer_from_cstring(symbol_666, sizeof(symbol_666)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4260,7 +4279,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_662, sizeof(symbol_662)-1);
+    data = buffer_from_cstring(symbol_667, sizeof(symbol_667)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4273,7 +4292,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_663, sizeof(symbol_663)-1);
+    data = buffer_from_cstring(symbol_668, sizeof(symbol_668)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4286,7 +4305,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_664, sizeof(symbol_664)-1);
+    data = buffer_from_cstring(symbol_669, sizeof(symbol_669)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4299,7 +4318,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_665, sizeof(symbol_665)-1);
+    data = buffer_from_cstring(symbol_670, sizeof(symbol_670)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4312,7 +4331,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_666, sizeof(symbol_666)-1);
+    data = buffer_from_cstring(symbol_671, sizeof(symbol_671)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4325,7 +4344,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_667, sizeof(symbol_667)-1);
+    data = buffer_from_cstring(symbol_672, sizeof(symbol_672)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4338,7 +4357,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_668, sizeof(symbol_668)-1);
+    data = buffer_from_cstring(symbol_673, sizeof(symbol_673)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4402,7 +4421,7 @@ struct Action* rule_spacechar(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_669, sizeof(symbol_669)-1);
+    data = buffer_from_cstring(symbol_674, sizeof(symbol_674)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4415,7 +4434,7 @@ struct Action* rule_spacechar(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_670, sizeof(symbol_670)-1);
+    data = buffer_from_cstring(symbol_675, sizeof(symbol_675)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 4a816a8..5bebd12 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -544,7 +544,9 @@ digit =
 
 placeholder
     = '{' space string:x '*' expr:y space '}' -> {
-        "append_data(runtime->current_chunks, " x "*" y ", 0, NULL);\n"
+        "for (int i=0; i < " y "; i++) {\n" >
+            "append_data(runtime->current_chunks, " x ", 0, NULL);\n"
+        < "}\n"
     }
     ;
 
@@ -569,7 +571,7 @@ dotname = nameAsSymbol:x nextname*:xs -> {
     "lookup_action(variables, " x ")" xs
 };
 
-nextname = '.' name;
+nextname = '.' name:x -> { "->" x };
 
 wvar = 'W[' .:x ']' -> {
     >namedWs {

2025-11-01 12:18 Rickard pushed to rlmeta2

commit 1fd639cbe4b25c363988caf0d7bb51a0c8362526
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 12:18:24 2025 +0100

    Fix some things for table (in progress...)

diff --git a/08_translate_to_c/rlmeta2.c b/08_translate_to_c/rlmeta2.c
index 40533be..6aaffec 100644
--- a/08_translate_to_c/rlmeta2.c
+++ b/08_translate_to_c/rlmeta2.c
@@ -265,6 +265,10 @@ unsigned int inc(unsigned int value, unsigned int amount) {
     return value + amount;
 }
 
+unsigned int max(unsigned int a, unsigned int b) {
+    return a > b ? a : b;
+}
+
 void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {
     fprintf(stderr, "debug: render chunks\n");
     if (chunks) {
@@ -553,408 +557,414 @@ static char symbol_259[] = "unsigned int inc(unsigned int value, unsigned int am
 static char symbol_260[] = "return value + amount;\n";
 static char symbol_261[] = "}\n";
 static char symbol_262[] = "\n";
-static char symbol_263[] = "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n";
-static char symbol_264[] = "fprintf(stderr, \"debug: render chunks\\n\");\n";
-static char symbol_265[] = "if (chunks) {\n";
-static char symbol_266[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
-static char symbol_267[] = "while (chunk) {\n";
-static char symbol_268[] = "*indent += chunk->indentation_delta;\n";
-static char symbol_269[] = "if (chunk->data) {\n";
-static char symbol_270[] = "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n";
-static char symbol_271[] = "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n";
-static char symbol_272[] = "for (int i=0; i<chunk->data->size; i++) {\n";
-static char symbol_273[] = "if (*last_char == '\\n') {\n";
-static char symbol_274[] = "for (int j=0; j<*indent; j++) {\n";
-static char symbol_275[] = "printf(\"    \");\n";
-static char symbol_276[] = "}\n";
-static char symbol_277[] = "}\n";
-static char symbol_278[] = "*last_char = chunk->data->buffer[i];\n";
-static char symbol_279[] = "putchar(*last_char);\n";
-static char symbol_280[] = "fflush(stdout);\n";
+static char symbol_263[] = "unsigned int max(unsigned int a, unsigned int b) {\n";
+static char symbol_264[] = "return a > b ? a : b;\n";
+static char symbol_265[] = "}\n";
+static char symbol_266[] = "\n";
+static char symbol_267[] = "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n";
+static char symbol_268[] = "fprintf(stderr, \"debug: render chunks\\n\");\n";
+static char symbol_269[] = "if (chunks) {\n";
+static char symbol_270[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
+static char symbol_271[] = "while (chunk) {\n";
+static char symbol_272[] = "*indent += chunk->indentation_delta;\n";
+static char symbol_273[] = "if (chunk->data) {\n";
+static char symbol_274[] = "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n";
+static char symbol_275[] = "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n";
+static char symbol_276[] = "for (int i=0; i<chunk->data->size; i++) {\n";
+static char symbol_277[] = "if (*last_char == '\\n') {\n";
+static char symbol_278[] = "for (int j=0; j<*indent; j++) {\n";
+static char symbol_279[] = "printf(\"    \");\n";
+static char symbol_280[] = "}\n";
 static char symbol_281[] = "}\n";
-static char symbol_282[] = "}\n";
-static char symbol_283[] = "render_chunks(chunk->chunks, last_char, indent);\n";
-static char symbol_284[] = "chunk = chunk->next;\n";
+static char symbol_282[] = "*last_char = chunk->data->buffer[i];\n";
+static char symbol_283[] = "putchar(*last_char);\n";
+static char symbol_284[] = "fflush(stdout);\n";
 static char symbol_285[] = "}\n";
 static char symbol_286[] = "}\n";
-static char symbol_287[] = "}\n";
-static char symbol_288[] = "\n";
-static char symbol_289[] = "\n";
-static char symbol_290[] = "xs";
-static char symbol_291[] = "int main(void) {\n";
-static char symbol_292[] = "arena_limit = 2<<30;\n";
-static char symbol_293[] = "arena_pos = 0;\n";
-static char symbol_294[] = "arena = malloc(arena_limit);\n";
-static char symbol_295[] = "struct ParseState* parse_state = create_parse_state_from_stdin();\n";
-static char symbol_296[] = "char last_char = '\\n';\n";
-static char symbol_297[] = "int indent = 0;\n";
-static char symbol_298[] = "fprintf(stderr, parse_state->input_buffer->buffer);\n";
-static char symbol_299[] = "struct Runtime* runtime = create_runtime();\n";
-static char symbol_300[] = "struct Action* action = rule_main(parse_state);\n";
-static char symbol_301[] = "struct Placeholder* placeholder;\n";
-static char symbol_302[] = "if (action == NULL) {\n";
-static char symbol_303[] = "fprintf(stderr, \"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n";
-static char symbol_304[] = "exit(1);\n";
-static char symbol_305[] = "}\n";
-static char symbol_306[] = "run_action(action, runtime);\n";
-static char symbol_307[] = "placeholder = runtime->placeholders->pre_first->next;\n";
-static char symbol_308[] = "while (placeholder) {\n";
-static char symbol_309[] = "runtime->current_chunks = placeholder->chunks;\n";
-static char symbol_310[] = "run_action(placeholder->action, runtime);\n";
-static char symbol_311[] = "placeholder = placeholder->next;\n";
-static char symbol_312[] = "}\n";
-static char symbol_313[] = "fprintf(stderr, \"debug: arena memory = %p\\n\", arena);\n";
-static char symbol_314[] = "fprintf(stderr, \"debug: arena limit  = %u\\n\", arena_limit);\n";
-static char symbol_315[] = "fprintf(stderr, \"debug: arena used   = %u\\n\", arena_pos);\n";
-static char symbol_316[] = "render_chunks(runtime->main_chunks, &last_char, &indent);\n";
-static char symbol_317[] = "}\n";
-static char symbol_318[] = "x";
-static char symbol_319[] = "=";
-static char symbol_320[] = "y";
-static char symbol_321[] = ";";
-static char symbol_322[] = "struct Action* rule_";
-static char symbol_323[] = "x";
-static char symbol_324[] = "(struct ParseState* parse_state);\n";
-static char symbol_325[] = "struct Action* rule_";
-static char symbol_326[] = "x";
-static char symbol_327[] = "(struct ParseState* parse_state) {\n";
-static char symbol_328[] = "unsigned int or_backtrack_pos;\n";
-static char symbol_329[] = "unsigned int action_start_pos;\n";
-static char symbol_330[] = "unsigned int star_start_pos;\n";
-static char symbol_331[] = "unsigned int star_pos;\n";
-static char symbol_332[] = "unsigned int nlookahead_pos;\n";
-static char symbol_333[] = "struct Variables* variables;\n";
-static char symbol_334[] = "struct Variables* star_variables;\n";
-static char symbol_335[] = "struct Action* _;\n";
-static char symbol_336[] = "struct Buffer* data;\n";
-static char symbol_337[] = "fprintf(stderr, \"debug: rule ";
-static char symbol_338[] = "x";
-static char symbol_339[] = " [pos=%d]\\n\", parse_state->pos);\n";
-static char symbol_340[] = "y";
-static char symbol_341[] = "fprintf(stderr, \"debug: rule fail ";
+static char symbol_287[] = "render_chunks(chunk->chunks, last_char, indent);\n";
+static char symbol_288[] = "chunk = chunk->next;\n";
+static char symbol_289[] = "}\n";
+static char symbol_290[] = "}\n";
+static char symbol_291[] = "}\n";
+static char symbol_292[] = "\n";
+static char symbol_293[] = "\n";
+static char symbol_294[] = "xs";
+static char symbol_295[] = "int main(void) {\n";
+static char symbol_296[] = "arena_limit = 2<<30;\n";
+static char symbol_297[] = "arena_pos = 0;\n";
+static char symbol_298[] = "arena = malloc(arena_limit);\n";
+static char symbol_299[] = "struct ParseState* parse_state = create_parse_state_from_stdin();\n";
+static char symbol_300[] = "char last_char = '\\n';\n";
+static char symbol_301[] = "int indent = 0;\n";
+static char symbol_302[] = "fprintf(stderr, parse_state->input_buffer->buffer);\n";
+static char symbol_303[] = "struct Runtime* runtime = create_runtime();\n";
+static char symbol_304[] = "struct Action* action = rule_main(parse_state);\n";
+static char symbol_305[] = "struct Placeholder* placeholder;\n";
+static char symbol_306[] = "if (action == NULL) {\n";
+static char symbol_307[] = "fprintf(stderr, \"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n";
+static char symbol_308[] = "exit(1);\n";
+static char symbol_309[] = "}\n";
+static char symbol_310[] = "run_action(action, runtime);\n";
+static char symbol_311[] = "placeholder = runtime->placeholders->pre_first->next;\n";
+static char symbol_312[] = "while (placeholder) {\n";
+static char symbol_313[] = "runtime->current_chunks = placeholder->chunks;\n";
+static char symbol_314[] = "run_action(placeholder->action, runtime);\n";
+static char symbol_315[] = "placeholder = placeholder->next;\n";
+static char symbol_316[] = "}\n";
+static char symbol_317[] = "fprintf(stderr, \"debug: arena memory = %p\\n\", arena);\n";
+static char symbol_318[] = "fprintf(stderr, \"debug: arena limit  = %u\\n\", arena_limit);\n";
+static char symbol_319[] = "fprintf(stderr, \"debug: arena used   = %u\\n\", arena_pos);\n";
+static char symbol_320[] = "render_chunks(runtime->main_chunks, &last_char, &indent);\n";
+static char symbol_321[] = "}\n";
+static char symbol_322[] = "x";
+static char symbol_323[] = "=";
+static char symbol_324[] = "y";
+static char symbol_325[] = ";";
+static char symbol_326[] = "struct Action* rule_";
+static char symbol_327[] = "x";
+static char symbol_328[] = "(struct ParseState* parse_state);\n";
+static char symbol_329[] = "struct Action* rule_";
+static char symbol_330[] = "x";
+static char symbol_331[] = "(struct ParseState* parse_state) {\n";
+static char symbol_332[] = "unsigned int or_backtrack_pos;\n";
+static char symbol_333[] = "unsigned int action_start_pos;\n";
+static char symbol_334[] = "unsigned int star_start_pos;\n";
+static char symbol_335[] = "unsigned int star_pos;\n";
+static char symbol_336[] = "unsigned int nlookahead_pos;\n";
+static char symbol_337[] = "struct Variables* variables;\n";
+static char symbol_338[] = "struct Variables* star_variables;\n";
+static char symbol_339[] = "struct Action* _;\n";
+static char symbol_340[] = "struct Buffer* data;\n";
+static char symbol_341[] = "fprintf(stderr, \"debug: rule ";
 static char symbol_342[] = "x";
 static char symbol_343[] = " [pos=%d]\\n\", parse_state->pos);\n";
-static char symbol_344[] = "return NULL;\n";
-static char symbol_345[] = "}\n";
-static char symbol_346[] = "\n";
-static char symbol_347[] = "x";
-static char symbol_348[] = "xs";
-static char symbol_349[] = "or_backtrack_pos = parse_state->pos;\n";
-static char symbol_350[] = "x";
-static char symbol_351[] = "xs";
-static char symbol_352[] = "x";
-static char symbol_353[] = "x";
-static char symbol_354[] = "|";
-static char symbol_355[] = "x";
-static char symbol_356[] = "parse_state->pos = or_backtrack_pos;\n";
-static char symbol_357[] = "action_start_pos = parse_state->pos;\n";
-static char symbol_358[] = "variables = create_variables();\n";
+static char symbol_344[] = "y";
+static char symbol_345[] = "fprintf(stderr, \"debug: rule fail ";
+static char symbol_346[] = "x";
+static char symbol_347[] = " [pos=%d]\\n\", parse_state->pos);\n";
+static char symbol_348[] = "return NULL;\n";
+static char symbol_349[] = "}\n";
+static char symbol_350[] = "\n";
+static char symbol_351[] = "x";
+static char symbol_352[] = "xs";
+static char symbol_353[] = "or_backtrack_pos = parse_state->pos;\n";
+static char symbol_354[] = "x";
+static char symbol_355[] = "xs";
+static char symbol_356[] = "x";
+static char symbol_357[] = "x";
+static char symbol_358[] = "|";
 static char symbol_359[] = "x";
-static char symbol_360[] = "x";
-static char symbol_361[] = "y";
-static char symbol_362[] = "x";
-static char symbol_363[] = "if (_) {\n";
-static char symbol_364[] = "y";
-static char symbol_365[] = "}\n";
-static char symbol_366[] = "y";
-static char symbol_367[] = "y";
-static char symbol_368[] = "!";
-static char symbol_369[] = "x";
-static char symbol_370[] = "nlookahead_pos = parse_state->pos;\n";
-static char symbol_371[] = "x";
-static char symbol_372[] = "if (_ == NULL) {\n";
-static char symbol_373[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);\n";
-static char symbol_374[] = "} else {\n";
-static char symbol_375[] = "_ = NULL;\n";
-static char symbol_376[] = "}\n";
-static char symbol_377[] = "parse_state->pos = nlookahead_pos;\n";
-static char symbol_378[] = "x";
-static char symbol_379[] = "y";
-static char symbol_380[] = "x";
-static char symbol_381[] = "y";
-static char symbol_382[] = ":";
-static char symbol_383[] = "x";
-static char symbol_384[] = "append_named_action(variables, ";
-static char symbol_385[] = "x";
-static char symbol_386[] = ", _);\n";
+static char symbol_360[] = "parse_state->pos = or_backtrack_pos;\n";
+static char symbol_361[] = "action_start_pos = parse_state->pos;\n";
+static char symbol_362[] = "variables = create_variables();\n";
+static char symbol_363[] = "x";
+static char symbol_364[] = "x";
+static char symbol_365[] = "y";
+static char symbol_366[] = "x";
+static char symbol_367[] = "if (_) {\n";
+static char symbol_368[] = "y";
+static char symbol_369[] = "}\n";
+static char symbol_370[] = "y";
+static char symbol_371[] = "y";
+static char symbol_372[] = "!";
+static char symbol_373[] = "x";
+static char symbol_374[] = "nlookahead_pos = parse_state->pos;\n";
+static char symbol_375[] = "x";
+static char symbol_376[] = "if (_ == NULL) {\n";
+static char symbol_377[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);\n";
+static char symbol_378[] = "} else {\n";
+static char symbol_379[] = "_ = NULL;\n";
+static char symbol_380[] = "}\n";
+static char symbol_381[] = "parse_state->pos = nlookahead_pos;\n";
+static char symbol_382[] = "x";
+static char symbol_383[] = "y";
+static char symbol_384[] = "x";
+static char symbol_385[] = "y";
+static char symbol_386[] = ":";
 static char symbol_387[] = "x";
-static char symbol_388[] = "*";
-static char symbol_389[] = "star_variables = create_variables();\n";
-static char symbol_390[] = "star_start_pos = parse_state->pos;\n";
-static char symbol_391[] = "while (1) {\n";
-static char symbol_392[] = "star_pos = parse_state->pos;\n";
-static char symbol_393[] = "x";
-static char symbol_394[] = "if (_ == NULL) {\n";
-static char symbol_395[] = "parse_state->pos = star_pos;\n";
-static char symbol_396[] = "break;\n";
-static char symbol_397[] = "}\n";
-static char symbol_398[] = "append_named_action(star_variables, NULL, _);\n";
-static char symbol_399[] = "}\n";
-static char symbol_400[] = "fprintf(stderr, \"debug: creating_star [%d, %d, %p]\\n\", star_start_pos, parse_state->pos, star_variables->pre_first->next);\n";
-static char symbol_401[] = "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n";
-static char symbol_402[] = "x";
-static char symbol_403[] = "x";
-static char symbol_404[] = "x";
-static char symbol_405[] = "_ = rule_";
+static char symbol_388[] = "append_named_action(variables, ";
+static char symbol_389[] = "x";
+static char symbol_390[] = ", _);\n";
+static char symbol_391[] = "x";
+static char symbol_392[] = "*";
+static char symbol_393[] = "star_variables = create_variables();\n";
+static char symbol_394[] = "star_start_pos = parse_state->pos;\n";
+static char symbol_395[] = "while (1) {\n";
+static char symbol_396[] = "star_pos = parse_state->pos;\n";
+static char symbol_397[] = "x";
+static char symbol_398[] = "if (_ == NULL) {\n";
+static char symbol_399[] = "parse_state->pos = star_pos;\n";
+static char symbol_400[] = "break;\n";
+static char symbol_401[] = "}\n";
+static char symbol_402[] = "append_named_action(star_variables, NULL, _);\n";
+static char symbol_403[] = "}\n";
+static char symbol_404[] = "fprintf(stderr, \"debug: creating_star [%d, %d, %p]\\n\", star_start_pos, parse_state->pos, star_variables->pre_first->next);\n";
+static char symbol_405[] = "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n";
 static char symbol_406[] = "x";
-static char symbol_407[] = "(parse_state);\n";
-static char symbol_408[] = ".";
-static char symbol_409[] = "if (parse_state->pos < parse_state->input_buffer->size) {\n";
-static char symbol_410[] = "parse_state->pos += 1;\n";
-static char symbol_411[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);\n";
-static char symbol_412[] = "} else {\n";
-static char symbol_413[] = "_ = NULL;\n";
-static char symbol_414[] = "}\n";
-static char symbol_415[] = "x";
-static char symbol_416[] = "data = ";
-static char symbol_417[] = "x";
-static char symbol_418[] = ";\n";
-static char symbol_419[] = "if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {\n";
-static char symbol_420[] = "parse_state->pos += data->size;\n";
-static char symbol_421[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);\n";
-static char symbol_422[] = "} else {\n";
-static char symbol_423[] = "_ = NULL;\n";
-static char symbol_424[] = "}\n";
-static char symbol_425[] = "->";
-static char symbol_426[] = "{";
-static char symbol_427[] = "xs";
-static char symbol_428[] = "}";
-static char symbol_429[] = "void action_";
-static char symbol_430[] = "(struct Runtime* runtime, struct Variables* variables) {\n";
-static char symbol_431[] = "struct Chunks* chunks;\n";
-static char symbol_432[] = "struct Chunks* last_chunks;\n";
-static char symbol_433[] = "struct Action* action;\n";
-static char symbol_434[] = "fprintf(stderr, \"debug: running action_";
-static char symbol_435[] = "\\n\");\n";
-static char symbol_436[] = "xs";
-static char symbol_437[] = "}\n";
-static char symbol_438[] = "\n";
-static char symbol_439[] = "return create_action(action_";
-static char symbol_440[] = ", variables, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
-static char symbol_441[] = "return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
-static char symbol_442[] = "unseen(";
-static char symbol_443[] = "x";
-static char symbol_444[] = ") -> {";
-static char symbol_445[] = "ys";
-static char symbol_446[] = "}";
-static char symbol_447[] = "action = lookup_action(variables, ";
-static char symbol_448[] = "x";
-static char symbol_449[] = ");\n";
-static char symbol_450[] = "if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {\n";
-static char symbol_451[] = "ys";
-static char symbol_452[] = "}\n";
-static char symbol_453[] = ">";
-static char symbol_454[] = "x";
-static char symbol_455[] = "{";
-static char symbol_456[] = "ys";
-static char symbol_457[] = "}";
-static char symbol_458[] = "last_chunks = runtime->current_chunks;\n";
-static char symbol_459[] = "chunks = runtime->named_chunks_";
-static char symbol_460[] = "x";
-static char symbol_461[] = ";\n";
-static char symbol_462[] = "runtime->current_chunks = chunks;\n";
-static char symbol_463[] = "ys";
-static char symbol_464[] = "runtime->current_chunks = last_chunks;\n";
-static char symbol_465[] = "<";
-static char symbol_466[] = "x";
-static char symbol_467[] = "chunks = create_chunks();\n";
-static char symbol_468[] = "runtime->named_chunks_";
-static char symbol_469[] = "x";
-static char symbol_470[] = " = chunks;\n";
-static char symbol_471[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
-static char symbol_472[] = "x";
-static char symbol_473[] = "append_data(runtime->current_chunks, buffer_from_integer(";
-static char symbol_474[] = "x";
-static char symbol_475[] = "), 0, NULL);\n";
+static char symbol_407[] = "x";
+static char symbol_408[] = "x";
+static char symbol_409[] = "_ = rule_";
+static char symbol_410[] = "x";
+static char symbol_411[] = "(parse_state);\n";
+static char symbol_412[] = ".";
+static char symbol_413[] = "if (parse_state->pos < parse_state->input_buffer->size) {\n";
+static char symbol_414[] = "parse_state->pos += 1;\n";
+static char symbol_415[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);\n";
+static char symbol_416[] = "} else {\n";
+static char symbol_417[] = "_ = NULL;\n";
+static char symbol_418[] = "}\n";
+static char symbol_419[] = "x";
+static char symbol_420[] = "data = ";
+static char symbol_421[] = "x";
+static char symbol_422[] = ";\n";
+static char symbol_423[] = "if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {\n";
+static char symbol_424[] = "parse_state->pos += data->size;\n";
+static char symbol_425[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);\n";
+static char symbol_426[] = "} else {\n";
+static char symbol_427[] = "_ = NULL;\n";
+static char symbol_428[] = "}\n";
+static char symbol_429[] = "->";
+static char symbol_430[] = "{";
+static char symbol_431[] = "xs";
+static char symbol_432[] = "}";
+static char symbol_433[] = "void action_";
+static char symbol_434[] = "(struct Runtime* runtime, struct Variables* variables) {\n";
+static char symbol_435[] = "struct Chunks* chunks;\n";
+static char symbol_436[] = "struct Chunks* last_chunks;\n";
+static char symbol_437[] = "struct Action* action;\n";
+static char symbol_438[] = "fprintf(stderr, \"debug: running action_";
+static char symbol_439[] = "\\n\");\n";
+static char symbol_440[] = "xs";
+static char symbol_441[] = "}\n";
+static char symbol_442[] = "\n";
+static char symbol_443[] = "return create_action(action_";
+static char symbol_444[] = ", variables, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
+static char symbol_445[] = "return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
+static char symbol_446[] = "unseen(";
+static char symbol_447[] = "x";
+static char symbol_448[] = ") -> {";
+static char symbol_449[] = "ys";
+static char symbol_450[] = "}";
+static char symbol_451[] = "action = lookup_action(variables, ";
+static char symbol_452[] = "x";
+static char symbol_453[] = ");\n";
+static char symbol_454[] = "if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {\n";
+static char symbol_455[] = "ys";
+static char symbol_456[] = "}\n";
+static char symbol_457[] = ">";
+static char symbol_458[] = "x";
+static char symbol_459[] = "{";
+static char symbol_460[] = "ys";
+static char symbol_461[] = "}";
+static char symbol_462[] = "last_chunks = runtime->current_chunks;\n";
+static char symbol_463[] = "chunks = runtime->named_chunks_";
+static char symbol_464[] = "x";
+static char symbol_465[] = ";\n";
+static char symbol_466[] = "runtime->current_chunks = chunks;\n";
+static char symbol_467[] = "ys";
+static char symbol_468[] = "runtime->current_chunks = last_chunks;\n";
+static char symbol_469[] = "<";
+static char symbol_470[] = "x";
+static char symbol_471[] = "chunks = create_chunks();\n";
+static char symbol_472[] = "runtime->named_chunks_";
+static char symbol_473[] = "x";
+static char symbol_474[] = " = chunks;\n";
+static char symbol_475[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
 static char symbol_476[] = "x";
-static char symbol_477[] = "run_action(lookup_action(variables, ";
+static char symbol_477[] = "append_data(runtime->current_chunks, buffer_from_integer(";
 static char symbol_478[] = "x";
-static char symbol_479[] = "), runtime);\n";
+static char symbol_479[] = "), 0, NULL);\n";
 static char symbol_480[] = "x";
-static char symbol_481[] = "void placeholder_";
-static char symbol_482[] = "(struct Runtime* runtime, struct Variables* variables) {";
-static char symbol_483[] = "x";
-static char symbol_484[] = "}\n";
-static char symbol_485[] = "\n";
-static char symbol_486[] = "chunks = create_chunks()\n";
-static char symbol_487[] = "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_";
-static char symbol_488[] = ", variables, '', 0, 0))\n";
-static char symbol_489[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
-static char symbol_490[] = "x";
-static char symbol_491[] = "append_data(runtime->current_chunks, ";
-static char symbol_492[] = "x";
-static char symbol_493[] = ", 0, NULL);\n";
-static char symbol_494[] = "#";
-static char symbol_495[] = "x";
-static char symbol_496[] = "(";
-static char symbol_497[] = "y";
-static char symbol_498[] = " ";
-static char symbol_499[] = "z";
-static char symbol_500[] = ")";
-static char symbol_501[] = "runtime->W_";
-static char symbol_502[] = "y";
-static char symbol_503[] = " = ";
-static char symbol_504[] = "x";
-static char symbol_505[] = "(runtime->W_";
-static char symbol_506[] = "y";
-static char symbol_507[] = " ? runtime->W_";
+static char symbol_481[] = "run_action(lookup_action(variables, ";
+static char symbol_482[] = "x";
+static char symbol_483[] = "), runtime);\n";
+static char symbol_484[] = "x";
+static char symbol_485[] = "void placeholder_";
+static char symbol_486[] = "(struct Runtime* runtime, struct Variables* variables);";
+static char symbol_487[] = "void placeholder_";
+static char symbol_488[] = "(struct Runtime* runtime, struct Variables* variables) {";
+static char symbol_489[] = "x";
+static char symbol_490[] = "}\n";
+static char symbol_491[] = "\n";
+static char symbol_492[] = "chunks = create_chunks();\n";
+static char symbol_493[] = "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_";
+static char symbol_494[] = ", variables, NULL, 0, 0));\n";
+static char symbol_495[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
+static char symbol_496[] = "x";
+static char symbol_497[] = "append_data(runtime->current_chunks, ";
+static char symbol_498[] = "x";
+static char symbol_499[] = ", 0, NULL);\n";
+static char symbol_500[] = "#";
+static char symbol_501[] = "x";
+static char symbol_502[] = "(";
+static char symbol_503[] = "y";
+static char symbol_504[] = " ";
+static char symbol_505[] = "z";
+static char symbol_506[] = ")";
+static char symbol_507[] = "runtime->W_";
 static char symbol_508[] = "y";
-static char symbol_509[] = " : 0, ";
-static char symbol_510[] = "z";
-static char symbol_511[] = ");\n";
-static char symbol_512[] = ">";
-static char symbol_513[] = "xs";
-static char symbol_514[] = "<";
-static char symbol_515[] = "append_data(runtime->current_chunks, NULL, 1, NULL);\n";
-static char symbol_516[] = "xs";
-static char symbol_517[] = "append_data(runtime->current_chunks, NULL, -1, NULL);\n";
-static char symbol_518[] = "x";
-static char symbol_519[] = "x";
-static char symbol_520[] = "struct Chunks* named_chunks_";
-static char symbol_521[] = "x";
-static char symbol_522[] = ";\n";
-static char symbol_523[] = "x";
+static char symbol_509[] = " = ";
+static char symbol_510[] = "x";
+static char symbol_511[] = "(runtime->W_";
+static char symbol_512[] = "y";
+static char symbol_513[] = " ? runtime->W_";
+static char symbol_514[] = "y";
+static char symbol_515[] = " : 0, ";
+static char symbol_516[] = "z";
+static char symbol_517[] = ");\n";
+static char symbol_518[] = ">";
+static char symbol_519[] = "xs";
+static char symbol_520[] = "<";
+static char symbol_521[] = "append_data(runtime->current_chunks, NULL, 1, NULL);\n";
+static char symbol_522[] = "xs";
+static char symbol_523[] = "append_data(runtime->current_chunks, NULL, -1, NULL);\n";
 static char symbol_524[] = "x";
 static char symbol_525[] = "x";
-static char symbol_526[] = "0";
-static char symbol_527[] = "1";
-static char symbol_528[] = "2";
-static char symbol_529[] = "3";
-static char symbol_530[] = "4";
-static char symbol_531[] = "5";
-static char symbol_532[] = "6";
-static char symbol_533[] = "7";
-static char symbol_534[] = "8";
-static char symbol_535[] = "9";
-static char symbol_536[] = "{";
-static char symbol_537[] = "x";
-static char symbol_538[] = "*";
-static char symbol_539[] = "y";
-static char symbol_540[] = "}";
-static char symbol_541[] = "append_data(runtime->current_chunks, ";
-static char symbol_542[] = "x";
-static char symbol_543[] = "*";
-static char symbol_544[] = "y";
-static char symbol_545[] = ", 0, NULL);\n";
-static char symbol_546[] = "x";
-static char symbol_547[] = "(runtime->W_";
+static char symbol_526[] = "struct Chunks* named_chunks_";
+static char symbol_527[] = "x";
+static char symbol_528[] = ";\n";
+static char symbol_529[] = "x";
+static char symbol_530[] = "x";
+static char symbol_531[] = "x";
+static char symbol_532[] = "0";
+static char symbol_533[] = "1";
+static char symbol_534[] = "2";
+static char symbol_535[] = "3";
+static char symbol_536[] = "4";
+static char symbol_537[] = "5";
+static char symbol_538[] = "6";
+static char symbol_539[] = "7";
+static char symbol_540[] = "8";
+static char symbol_541[] = "9";
+static char symbol_542[] = "{";
+static char symbol_543[] = "x";
+static char symbol_544[] = "*";
+static char symbol_545[] = "y";
+static char symbol_546[] = "}";
+static char symbol_547[] = "append_data(runtime->current_chunks, ";
 static char symbol_548[] = "x";
-static char symbol_549[] = " ? runtime->W_";
-static char symbol_550[] = "x";
-static char symbol_551[] = " : 0)";
-static char symbol_552[] = "(";
-static char symbol_553[] = "x";
-static char symbol_554[] = "-";
-static char symbol_555[] = "y";
-static char symbol_556[] = ")";
-static char symbol_557[] = "((runtime->W_";
-static char symbol_558[] = "x";
-static char symbol_559[] = " ? runtime->W_";
-static char symbol_560[] = "x";
-static char symbol_561[] = " : 0)-";
-static char symbol_562[] = "y";
-static char symbol_563[] = ")";
-static char symbol_564[] = "\"";
-static char symbol_565[] = "xs";
-static char symbol_566[] = "\"";
-static char symbol_567[] = "static char symbol_";
-static char symbol_568[] = "[] = \"";
-static char symbol_569[] = "xs";
-static char symbol_570[] = "\";\n";
-static char symbol_571[] = "buffer_from_cstring(symbol_";
-static char symbol_572[] = ", sizeof(symbol_";
-static char symbol_573[] = ")-1)";
-static char symbol_574[] = "x";
+static char symbol_549[] = "*";
+static char symbol_550[] = "y";
+static char symbol_551[] = ", 0, NULL);\n";
+static char symbol_552[] = "x";
+static char symbol_553[] = "(runtime->W_";
+static char symbol_554[] = "x";
+static char symbol_555[] = " ? runtime->W_";
+static char symbol_556[] = "x";
+static char symbol_557[] = " : 0)";
+static char symbol_558[] = "(";
+static char symbol_559[] = "x";
+static char symbol_560[] = "-";
+static char symbol_561[] = "y";
+static char symbol_562[] = ")";
+static char symbol_563[] = "((runtime->W_";
+static char symbol_564[] = "x";
+static char symbol_565[] = " ? runtime->W_";
+static char symbol_566[] = "x";
+static char symbol_567[] = " : 0)-";
+static char symbol_568[] = "y";
+static char symbol_569[] = ")";
+static char symbol_570[] = "\"";
+static char symbol_571[] = "xs";
+static char symbol_572[] = "\"";
+static char symbol_573[] = "static char symbol_";
+static char symbol_574[] = "[] = \"";
 static char symbol_575[] = "xs";
-static char symbol_576[] = "lookup_action(variables, ";
-static char symbol_577[] = "x";
-static char symbol_578[] = ")";
-static char symbol_579[] = "xs";
-static char symbol_580[] = ".";
-static char symbol_581[] = "W[";
-static char symbol_582[] = "x";
-static char symbol_583[] = "]";
-static char symbol_584[] = "x";
-static char symbol_585[] = "unsigned int W_";
-static char symbol_586[] = "x";
-static char symbol_587[] = ";\n";
+static char symbol_576[] = "\";\n";
+static char symbol_577[] = "buffer_from_cstring(symbol_";
+static char symbol_578[] = ", sizeof(symbol_";
+static char symbol_579[] = ")-1)";
+static char symbol_580[] = "x";
+static char symbol_581[] = "xs";
+static char symbol_582[] = "lookup_action(variables, ";
+static char symbol_583[] = "x";
+static char symbol_584[] = ")";
+static char symbol_585[] = "xs";
+static char symbol_586[] = ".";
+static char symbol_587[] = "W[";
 static char symbol_588[] = "x";
-static char symbol_589[] = "\\\"";
-static char symbol_590[] = "\"";
-static char symbol_591[] = "xs";
-static char symbol_592[] = "static char symbol_";
-static char symbol_593[] = "[] = \"";
-static char symbol_594[] = "xs";
-static char symbol_595[] = "\";\n";
-static char symbol_596[] = "buffer_from_cstring(symbol_";
-static char symbol_597[] = ", sizeof(symbol_";
-static char symbol_598[] = ")-1)";
-static char symbol_599[] = "\'";
-static char symbol_600[] = "\\\'";
-static char symbol_601[] = "\"";
-static char symbol_602[] = "\\\"";
-static char symbol_603[] = "x";
-static char symbol_604[] = "static char symbol_";
-static char symbol_605[] = "[] = \"";
-static char symbol_606[] = "x";
-static char symbol_607[] = "\";\n";
-static char symbol_608[] = "buffer_from_cstring(symbol_";
-static char symbol_609[] = ", sizeof(symbol_";
-static char symbol_610[] = ")-1)";
-static char symbol_611[] = "a";
-static char symbol_612[] = "b";
-static char symbol_613[] = "c";
-static char symbol_614[] = "d";
-static char symbol_615[] = "e";
-static char symbol_616[] = "f";
-static char symbol_617[] = "g";
-static char symbol_618[] = "h";
-static char symbol_619[] = "i";
-static char symbol_620[] = "j";
-static char symbol_621[] = "k";
-static char symbol_622[] = "l";
-static char symbol_623[] = "m";
-static char symbol_624[] = "n";
-static char symbol_625[] = "o";
-static char symbol_626[] = "p";
-static char symbol_627[] = "q";
-static char symbol_628[] = "r";
-static char symbol_629[] = "s";
-static char symbol_630[] = "t";
-static char symbol_631[] = "u";
-static char symbol_632[] = "v";
-static char symbol_633[] = "w";
-static char symbol_634[] = "x";
-static char symbol_635[] = "y";
-static char symbol_636[] = "z";
-static char symbol_637[] = "A";
-static char symbol_638[] = "B";
-static char symbol_639[] = "C";
-static char symbol_640[] = "D";
-static char symbol_641[] = "E";
-static char symbol_642[] = "F";
-static char symbol_643[] = "G";
-static char symbol_644[] = "H";
-static char symbol_645[] = "I";
-static char symbol_646[] = "J";
-static char symbol_647[] = "K";
-static char symbol_648[] = "L";
-static char symbol_649[] = "M";
-static char symbol_650[] = "N";
-static char symbol_651[] = "O";
-static char symbol_652[] = "P";
-static char symbol_653[] = "Q";
-static char symbol_654[] = "R";
-static char symbol_655[] = "S";
-static char symbol_656[] = "T";
-static char symbol_657[] = "U";
-static char symbol_658[] = "V";
-static char symbol_659[] = "W";
-static char symbol_660[] = "X";
-static char symbol_661[] = "Y";
-static char symbol_662[] = "Z";
-static char symbol_663[] = " ";
-static char symbol_664[] = "\n";
+static char symbol_589[] = "]";
+static char symbol_590[] = "x";
+static char symbol_591[] = "unsigned int W_";
+static char symbol_592[] = "x";
+static char symbol_593[] = ";\n";
+static char symbol_594[] = "x";
+static char symbol_595[] = "\\\"";
+static char symbol_596[] = "\"";
+static char symbol_597[] = "xs";
+static char symbol_598[] = "static char symbol_";
+static char symbol_599[] = "[] = \"";
+static char symbol_600[] = "xs";
+static char symbol_601[] = "\";\n";
+static char symbol_602[] = "buffer_from_cstring(symbol_";
+static char symbol_603[] = ", sizeof(symbol_";
+static char symbol_604[] = ")-1)";
+static char symbol_605[] = "\'";
+static char symbol_606[] = "\\\'";
+static char symbol_607[] = "\"";
+static char symbol_608[] = "\\\"";
+static char symbol_609[] = "x";
+static char symbol_610[] = "static char symbol_";
+static char symbol_611[] = "[] = \"";
+static char symbol_612[] = "x";
+static char symbol_613[] = "\";\n";
+static char symbol_614[] = "buffer_from_cstring(symbol_";
+static char symbol_615[] = ", sizeof(symbol_";
+static char symbol_616[] = ")-1)";
+static char symbol_617[] = "a";
+static char symbol_618[] = "b";
+static char symbol_619[] = "c";
+static char symbol_620[] = "d";
+static char symbol_621[] = "e";
+static char symbol_622[] = "f";
+static char symbol_623[] = "g";
+static char symbol_624[] = "h";
+static char symbol_625[] = "i";
+static char symbol_626[] = "j";
+static char symbol_627[] = "k";
+static char symbol_628[] = "l";
+static char symbol_629[] = "m";
+static char symbol_630[] = "n";
+static char symbol_631[] = "o";
+static char symbol_632[] = "p";
+static char symbol_633[] = "q";
+static char symbol_634[] = "r";
+static char symbol_635[] = "s";
+static char symbol_636[] = "t";
+static char symbol_637[] = "u";
+static char symbol_638[] = "v";
+static char symbol_639[] = "w";
+static char symbol_640[] = "x";
+static char symbol_641[] = "y";
+static char symbol_642[] = "z";
+static char symbol_643[] = "A";
+static char symbol_644[] = "B";
+static char symbol_645[] = "C";
+static char symbol_646[] = "D";
+static char symbol_647[] = "E";
+static char symbol_648[] = "F";
+static char symbol_649[] = "G";
+static char symbol_650[] = "H";
+static char symbol_651[] = "I";
+static char symbol_652[] = "J";
+static char symbol_653[] = "K";
+static char symbol_654[] = "L";
+static char symbol_655[] = "M";
+static char symbol_656[] = "N";
+static char symbol_657[] = "O";
+static char symbol_658[] = "P";
+static char symbol_659[] = "Q";
+static char symbol_660[] = "R";
+static char symbol_661[] = "S";
+static char symbol_662[] = "T";
+static char symbol_663[] = "U";
+static char symbol_664[] = "V";
+static char symbol_665[] = "W";
+static char symbol_666[] = "X";
+static char symbol_667[] = "Y";
+static char symbol_668[] = "Z";
+static char symbol_669[] = " ";
+static char symbol_670[] = "\n";
 struct Action* rule_main(struct ParseState* parse_state);
 struct Action* rule_file(struct ParseState* parse_state);
 struct Action* rule_rule(struct ParseState* parse_state);
@@ -1361,8 +1371,8 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_263, sizeof(symbol_263)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_264, sizeof(symbol_264)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_265, sizeof(symbol_265)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_266, sizeof(symbol_266)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_267, sizeof(symbol_267)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
@@ -1371,23 +1381,23 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_270, sizeof(symbol_270)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_271, sizeof(symbol_271)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_272, sizeof(symbol_272)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_272, sizeof(symbol_272)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_273, sizeof(symbol_273)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_274, sizeof(symbol_274)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_275, sizeof(symbol_275)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_276, sizeof(symbol_276)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_277, sizeof(symbol_277)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_278, sizeof(symbol_278)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_279, sizeof(symbol_279)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_280, sizeof(symbol_280)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_281, sizeof(symbol_281)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_282, sizeof(symbol_282)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_283, sizeof(symbol_283)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_284, sizeof(symbol_284)-1), 0, NULL);
@@ -1395,29 +1405,31 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_285, sizeof(symbol_285)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_286, sizeof(symbol_286)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_287, sizeof(symbol_287)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_288, sizeof(symbol_288)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_289, sizeof(symbol_289)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_290, sizeof(symbol_290)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_291, sizeof(symbol_291)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_292, sizeof(symbol_292)-1), 0, NULL);
     chunks = create_chunks();
     runtime->named_chunks_symbols = chunks;
     append_data(runtime->current_chunks, NULL, 0, chunks);
     chunks = create_chunks();
     runtime->named_chunks_definitions = chunks;
     append_data(runtime->current_chunks, NULL, 0, chunks);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_289, sizeof(symbol_289)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_293, sizeof(symbol_293)-1), 0, NULL);
     chunks = create_chunks();
     runtime->named_chunks_actions = chunks;
     append_data(runtime->current_chunks, NULL, 0, chunks);
     chunks = create_chunks();
     runtime->named_chunks_placeholders = chunks;
     append_data(runtime->current_chunks, NULL, 0, chunks);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_290, sizeof(symbol_290)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_291, sizeof(symbol_291)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_292, sizeof(symbol_292)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_293, sizeof(symbol_293)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_294, sizeof(symbol_294)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_294, sizeof(symbol_294)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_295, sizeof(symbol_295)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_296, sizeof(symbol_296)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_297, sizeof(symbol_297)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_298, sizeof(symbol_298)-1), 0, NULL);
@@ -1425,26 +1437,30 @@ void action_2(struct Runtime* runtime, struct Variables* variables) {
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_300, sizeof(symbol_300)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_301, sizeof(symbol_301)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_302, sizeof(symbol_302)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_303, sizeof(symbol_303)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_304, sizeof(symbol_304)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_305, sizeof(symbol_305)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_306, sizeof(symbol_306)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_307, sizeof(symbol_307)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_308, sizeof(symbol_308)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_309, sizeof(symbol_309)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_310, sizeof(symbol_310)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_311, sizeof(symbol_311)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_312, sizeof(symbol_312)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_313, sizeof(symbol_313)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_314, sizeof(symbol_314)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_315, sizeof(symbol_315)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_316, sizeof(symbol_316)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_316, sizeof(symbol_316)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_317, sizeof(symbol_317)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_318, sizeof(symbol_318)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_319, sizeof(symbol_319)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_320, sizeof(symbol_320)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_321, sizeof(symbol_321)-1), 0, NULL);
 }
 
 void action_3(struct Runtime* runtime, struct Variables* variables) {
@@ -1455,34 +1471,34 @@ void action_3(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_definitions;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_322, sizeof(symbol_322)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_323, sizeof(symbol_323)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_324, sizeof(symbol_324)-1), 0, NULL);
-    runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_325, sizeof(symbol_325)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_326, sizeof(symbol_326)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_327, sizeof(symbol_327)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_326, sizeof(symbol_326)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_327, sizeof(symbol_327)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_328, sizeof(symbol_328)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_329, sizeof(symbol_329)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_330, sizeof(symbol_330)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_330, sizeof(symbol_330)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_331, sizeof(symbol_331)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_332, sizeof(symbol_332)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_333, sizeof(symbol_333)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_334, sizeof(symbol_334)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_335, sizeof(symbol_335)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_336, sizeof(symbol_336)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_337, sizeof(symbol_337)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_338, sizeof(symbol_338)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_338, sizeof(symbol_338)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_339, sizeof(symbol_339)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_340, sizeof(symbol_340)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_340, sizeof(symbol_340)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_341, sizeof(symbol_341)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_342, sizeof(symbol_342)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_343, sizeof(symbol_343)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_344, sizeof(symbol_344)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_344, sizeof(symbol_344)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_345, sizeof(symbol_345)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_346, sizeof(symbol_346)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_346, sizeof(symbol_346)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_347, sizeof(symbol_347)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_348, sizeof(symbol_348)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_349, sizeof(symbol_349)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_350, sizeof(symbol_350)-1), 0, NULL);
 }
 
 void action_4(struct Runtime* runtime, struct Variables* variables) {
@@ -1490,9 +1506,9 @@ void action_4(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_4\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_349, sizeof(symbol_349)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_350, sizeof(symbol_350)-1)), runtime);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_351, sizeof(symbol_351)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_353, sizeof(symbol_353)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_354, sizeof(symbol_354)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_355, sizeof(symbol_355)-1)), runtime);
 }
 
 void action_5(struct Runtime* runtime, struct Variables* variables) {
@@ -1500,7 +1516,7 @@ void action_5(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_5\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_353, sizeof(symbol_353)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_357, sizeof(symbol_357)-1)), runtime);
 }
 
 void action_6(struct Runtime* runtime, struct Variables* variables) {
@@ -1515,10 +1531,10 @@ void action_7(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_7\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_356, sizeof(symbol_356)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_357, sizeof(symbol_357)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_358, sizeof(symbol_358)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_359, sizeof(symbol_359)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_360, sizeof(symbol_360)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_361, sizeof(symbol_361)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_362, sizeof(symbol_362)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_363, sizeof(symbol_363)-1)), runtime);
 }
 
 void action_8(struct Runtime* runtime, struct Variables* variables) {
@@ -1526,12 +1542,12 @@ void action_8(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_8\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_362, sizeof(symbol_362)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_363, sizeof(symbol_363)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_366, sizeof(symbol_366)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_367, sizeof(symbol_367)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_364, sizeof(symbol_364)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_368, sizeof(symbol_368)-1)), runtime);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_365, sizeof(symbol_365)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_369, sizeof(symbol_369)-1), 0, NULL);
 }
 
 void action_9(struct Runtime* runtime, struct Variables* variables) {
@@ -1539,7 +1555,7 @@ void action_9(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_9\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_367, sizeof(symbol_367)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_371, sizeof(symbol_371)-1)), runtime);
 }
 
 void action_10(struct Runtime* runtime, struct Variables* variables) {
@@ -1547,18 +1563,18 @@ void action_10(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_10\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_370, sizeof(symbol_370)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_371, sizeof(symbol_371)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_372, sizeof(symbol_372)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_374, sizeof(symbol_374)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_375, sizeof(symbol_375)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_376, sizeof(symbol_376)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_373, sizeof(symbol_373)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_377, sizeof(symbol_377)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_374, sizeof(symbol_374)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_378, sizeof(symbol_378)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_375, sizeof(symbol_375)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_379, sizeof(symbol_379)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_376, sizeof(symbol_376)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_377, sizeof(symbol_377)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_380, sizeof(symbol_380)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_381, sizeof(symbol_381)-1), 0, NULL);
 }
 
 void action_11(struct Runtime* runtime, struct Variables* variables) {
@@ -1566,8 +1582,8 @@ void action_11(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_11\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_380, sizeof(symbol_380)-1)), runtime);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_381, sizeof(symbol_381)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_384, sizeof(symbol_384)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_385, sizeof(symbol_385)-1)), runtime);
 }
 
 void action_12(struct Runtime* runtime, struct Variables* variables) {
@@ -1575,9 +1591,9 @@ void action_12(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_12\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_384, sizeof(symbol_384)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_385, sizeof(symbol_385)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_386, sizeof(symbol_386)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_388, sizeof(symbol_388)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_389, sizeof(symbol_389)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_390, sizeof(symbol_390)-1), 0, NULL);
 }
 
 void action_13(struct Runtime* runtime, struct Variables* variables) {
@@ -1592,23 +1608,23 @@ void action_14(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_14\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_389, sizeof(symbol_389)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_390, sizeof(symbol_390)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_391, sizeof(symbol_391)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_392, sizeof(symbol_392)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_393, sizeof(symbol_393)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_393, sizeof(symbol_393)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_394, sizeof(symbol_394)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_395, sizeof(symbol_395)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_396, sizeof(symbol_396)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_397, sizeof(symbol_397)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_397, sizeof(symbol_397)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_398, sizeof(symbol_398)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_399, sizeof(symbol_399)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_400, sizeof(symbol_400)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_401, sizeof(symbol_401)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_402, sizeof(symbol_402)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_403, sizeof(symbol_403)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_404, sizeof(symbol_404)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_405, sizeof(symbol_405)-1), 0, NULL);
 }
 
 void action_15(struct Runtime* runtime, struct Variables* variables) {
@@ -1616,7 +1632,7 @@ void action_15(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_15\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_403, sizeof(symbol_403)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_407, sizeof(symbol_407)-1)), runtime);
 }
 
 void action_16(struct Runtime* runtime, struct Variables* variables) {
@@ -1624,9 +1640,9 @@ void action_16(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_16\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_405, sizeof(symbol_405)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_406, sizeof(symbol_406)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_407, sizeof(symbol_407)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_409, sizeof(symbol_409)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_410, sizeof(symbol_410)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_411, sizeof(symbol_411)-1), 0, NULL);
 }
 
 void action_17(struct Runtime* runtime, struct Variables* variables) {
@@ -1634,16 +1650,16 @@ void action_17(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_17\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_409, sizeof(symbol_409)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_413, sizeof(symbol_413)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_410, sizeof(symbol_410)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_411, sizeof(symbol_411)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_414, sizeof(symbol_414)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_415, sizeof(symbol_415)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_412, sizeof(symbol_412)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_416, sizeof(symbol_416)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_413, sizeof(symbol_413)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_417, sizeof(symbol_417)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_414, sizeof(symbol_414)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_418, sizeof(symbol_418)-1), 0, NULL);
 }
 
 void action_18(struct Runtime* runtime, struct Variables* variables) {
@@ -1651,19 +1667,19 @@ void action_18(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_18\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_416, sizeof(symbol_416)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_417, sizeof(symbol_417)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_418, sizeof(symbol_418)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_419, sizeof(symbol_419)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_420, sizeof(symbol_420)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_421, sizeof(symbol_421)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_421, sizeof(symbol_421)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_422, sizeof(symbol_422)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_423, sizeof(symbol_423)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_424, sizeof(symbol_424)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_425, sizeof(symbol_425)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_426, sizeof(symbol_426)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_427, sizeof(symbol_427)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_428, sizeof(symbol_428)-1), 0, NULL);
 }
 
 void action_19(struct Runtime* runtime, struct Variables* variables) {
@@ -1675,24 +1691,24 @@ void action_19(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_actions;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_429, sizeof(symbol_429)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_430, sizeof(symbol_430)-1), 0, NULL);
-    append_data(runtime->current_chunks, NULL, 1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_431, sizeof(symbol_431)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_432, sizeof(symbol_432)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_433, sizeof(symbol_433)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_434, sizeof(symbol_434)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_434, sizeof(symbol_434)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_435, sizeof(symbol_435)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_436, sizeof(symbol_436)-1)), runtime);
-    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_436, sizeof(symbol_436)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_437, sizeof(symbol_437)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_438, sizeof(symbol_438)-1), 0, NULL);
-    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_439, sizeof(symbol_439)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_440, sizeof(symbol_440)-1)), runtime);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_441, sizeof(symbol_441)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_442, sizeof(symbol_442)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_443, sizeof(symbol_443)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_440, sizeof(symbol_440)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_444, sizeof(symbol_444)-1), 0, NULL);
 }
 
 void action_20(struct Runtime* runtime, struct Variables* variables) {
@@ -1700,7 +1716,7 @@ void action_20(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_20\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_441, sizeof(symbol_441)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_445, sizeof(symbol_445)-1), 0, NULL);
 }
 
 void action_21(struct Runtime* runtime, struct Variables* variables) {
@@ -1708,14 +1724,14 @@ void action_21(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_21\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_447, sizeof(symbol_447)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_448, sizeof(symbol_448)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_449, sizeof(symbol_449)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_450, sizeof(symbol_450)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_451, sizeof(symbol_451)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_452, sizeof(symbol_452)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_453, sizeof(symbol_453)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_454, sizeof(symbol_454)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_451, sizeof(symbol_451)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_455, sizeof(symbol_455)-1)), runtime);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_452, sizeof(symbol_452)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_456, sizeof(symbol_456)-1), 0, NULL);
 }
 
 void action_22(struct Runtime* runtime, struct Variables* variables) {
@@ -1723,13 +1739,13 @@ void action_22(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_22\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_458, sizeof(symbol_458)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_459, sizeof(symbol_459)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_460, sizeof(symbol_460)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_461, sizeof(symbol_461)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_462, sizeof(symbol_462)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_463, sizeof(symbol_463)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_464, sizeof(symbol_464)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_463, sizeof(symbol_463)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_464, sizeof(symbol_464)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_465, sizeof(symbol_465)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_466, sizeof(symbol_466)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_467, sizeof(symbol_467)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_468, sizeof(symbol_468)-1), 0, NULL);
 }
 
 void action_23(struct Runtime* runtime, struct Variables* variables) {
@@ -1737,11 +1753,11 @@ void action_23(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_23\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_467, sizeof(symbol_467)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_468, sizeof(symbol_468)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_469, sizeof(symbol_469)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_470, sizeof(symbol_470)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_471, sizeof(symbol_471)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_472, sizeof(symbol_472)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_473, sizeof(symbol_473)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_474, sizeof(symbol_474)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_475, sizeof(symbol_475)-1), 0, NULL);
 }
 
 void action_24(struct Runtime* runtime, struct Variables* variables) {
@@ -1749,9 +1765,9 @@ void action_24(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_24\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_473, sizeof(symbol_473)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_474, sizeof(symbol_474)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_475, sizeof(symbol_475)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_477, sizeof(symbol_477)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_478, sizeof(symbol_478)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_479, sizeof(symbol_479)-1), 0, NULL);
 }
 
 void action_25(struct Runtime* runtime, struct Variables* variables) {
@@ -1759,9 +1775,9 @@ void action_25(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_25\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_477, sizeof(symbol_477)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_478, sizeof(symbol_478)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_479, sizeof(symbol_479)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_481, sizeof(symbol_481)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_482, sizeof(symbol_482)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_483, sizeof(symbol_483)-1), 0, NULL);
 }
 
 void action_26(struct Runtime* runtime, struct Variables* variables) {
@@ -1771,22 +1787,29 @@ void action_26(struct Runtime* runtime, struct Variables* variables) {
     fprintf(stderr, "debug: running action_26\n");
     runtime->W_1 = inc(runtime->W_1 ? runtime->W_1 : 0, 1);
     last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_definitions;
+    runtime->current_chunks = chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_485, sizeof(symbol_485)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_486, sizeof(symbol_486)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_placeholders;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_481, sizeof(symbol_481)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_487, sizeof(symbol_487)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_482, sizeof(symbol_482)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_488, sizeof(symbol_488)-1), 0, NULL);
     append_data(runtime->current_chunks, NULL, 1, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_483, sizeof(symbol_483)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_489, sizeof(symbol_489)-1)), runtime);
     append_data(runtime->current_chunks, NULL, -1, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_484, sizeof(symbol_484)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_485, sizeof(symbol_485)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_490, sizeof(symbol_490)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_491, sizeof(symbol_491)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_486, sizeof(symbol_486)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_487, sizeof(symbol_487)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_492, sizeof(symbol_492)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_493, sizeof(symbol_493)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_488, sizeof(symbol_488)-1), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_489, sizeof(symbol_489)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_494, sizeof(symbol_494)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_495, sizeof(symbol_495)-1), 0, NULL);
 }
 
 void action_27(struct Runtime* runtime, struct Variables* variables) {
@@ -1794,9 +1817,9 @@ void action_27(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_27\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_491, sizeof(symbol_491)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_492, sizeof(symbol_492)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_493, sizeof(symbol_493)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_497, sizeof(symbol_497)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_498, sizeof(symbol_498)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_499, sizeof(symbol_499)-1), 0, NULL);
 }
 
 void action_28(struct Runtime* runtime, struct Variables* variables) {
@@ -1804,17 +1827,17 @@ void action_28(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_28\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_501, sizeof(symbol_501)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_502, sizeof(symbol_502)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_503, sizeof(symbol_503)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_504, sizeof(symbol_504)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_505, sizeof(symbol_505)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_506, sizeof(symbol_506)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_507, sizeof(symbol_507)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_508, sizeof(symbol_508)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_509, sizeof(symbol_509)-1), 0, NULL);
     run_action(lookup_action(variables, buffer_from_cstring(symbol_510, sizeof(symbol_510)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_511, sizeof(symbol_511)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_512, sizeof(symbol_512)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_513, sizeof(symbol_513)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_514, sizeof(symbol_514)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_515, sizeof(symbol_515)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_516, sizeof(symbol_516)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_517, sizeof(symbol_517)-1), 0, NULL);
 }
 
 void action_29(struct Runtime* runtime, struct Variables* variables) {
@@ -1822,9 +1845,9 @@ void action_29(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_29\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_515, sizeof(symbol_515)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_516, sizeof(symbol_516)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_517, sizeof(symbol_517)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_521, sizeof(symbol_521)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_522, sizeof(symbol_522)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_523, sizeof(symbol_523)-1), 0, NULL);
 }
 
 void action_30(struct Runtime* runtime, struct Variables* variables) {
@@ -1835,14 +1858,14 @@ void action_30(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_namedChunks;
     runtime->current_chunks = chunks;
-    action = lookup_action(variables, buffer_from_cstring(symbol_519, sizeof(symbol_519)-1));
+    action = lookup_action(variables, buffer_from_cstring(symbol_525, sizeof(symbol_525)-1));
     if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_520, sizeof(symbol_520)-1), 0, NULL);
-        run_action(lookup_action(variables, buffer_from_cstring(symbol_521, sizeof(symbol_521)-1)), runtime);
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_522, sizeof(symbol_522)-1), 0, NULL);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_526, sizeof(symbol_526)-1), 0, NULL);
+        run_action(lookup_action(variables, buffer_from_cstring(symbol_527, sizeof(symbol_527)-1)), runtime);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_528, sizeof(symbol_528)-1), 0, NULL);
     }
     runtime->current_chunks = last_chunks;
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_523, sizeof(symbol_523)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_529, sizeof(symbol_529)-1)), runtime);
 }
 
 void action_31(struct Runtime* runtime, struct Variables* variables) {
@@ -1850,7 +1873,7 @@ void action_31(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_31\n");
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_525, sizeof(symbol_525)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_531, sizeof(symbol_531)-1)), runtime);
 }
 
 void action_32(struct Runtime* runtime, struct Variables* variables) {
@@ -1858,11 +1881,11 @@ void action_32(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_32\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_541, sizeof(symbol_541)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_542, sizeof(symbol_542)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_543, sizeof(symbol_543)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_544, sizeof(symbol_544)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_545, sizeof(symbol_545)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_547, sizeof(symbol_547)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_548, sizeof(symbol_548)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_549, sizeof(symbol_549)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_550, sizeof(symbol_550)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_551, sizeof(symbol_551)-1), 0, NULL);
 }
 
 void action_33(struct Runtime* runtime, struct Variables* variables) {
@@ -1870,11 +1893,11 @@ void action_33(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_33\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_547, sizeof(symbol_547)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_548, sizeof(symbol_548)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_549, sizeof(symbol_549)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_550, sizeof(symbol_550)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_551, sizeof(symbol_551)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_553, sizeof(symbol_553)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_554, sizeof(symbol_554)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_555, sizeof(symbol_555)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_556, sizeof(symbol_556)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_557, sizeof(symbol_557)-1), 0, NULL);
 }
 
 void action_34(struct Runtime* runtime, struct Variables* variables) {
@@ -1882,13 +1905,13 @@ void action_34(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_34\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_557, sizeof(symbol_557)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_558, sizeof(symbol_558)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_559, sizeof(symbol_559)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_560, sizeof(symbol_560)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_561, sizeof(symbol_561)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_562, sizeof(symbol_562)-1)), runtime);
     append_data(runtime->current_chunks, buffer_from_cstring(symbol_563, sizeof(symbol_563)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_564, sizeof(symbol_564)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_565, sizeof(symbol_565)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_566, sizeof(symbol_566)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_567, sizeof(symbol_567)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_568, sizeof(symbol_568)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_569, sizeof(symbol_569)-1), 0, NULL);
 }
 
 void action_35(struct Runtime* runtime, struct Variables* variables) {
@@ -1900,17 +1923,17 @@ void action_35(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_567, sizeof(symbol_567)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_573, sizeof(symbol_573)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_568, sizeof(symbol_568)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_569, sizeof(symbol_569)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_570, sizeof(symbol_570)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_574, sizeof(symbol_574)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_575, sizeof(symbol_575)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_576, sizeof(symbol_576)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_571, sizeof(symbol_571)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_577, sizeof(symbol_577)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_572, sizeof(symbol_572)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_578, sizeof(symbol_578)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_573, sizeof(symbol_573)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_579, sizeof(symbol_579)-1), 0, NULL);
 }
 
 void action_36(struct Runtime* runtime, struct Variables* variables) {
@@ -1918,10 +1941,10 @@ void action_36(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_36\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_576, sizeof(symbol_576)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_577, sizeof(symbol_577)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_578, sizeof(symbol_578)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_579, sizeof(symbol_579)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_582, sizeof(symbol_582)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_583, sizeof(symbol_583)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_584, sizeof(symbol_584)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_585, sizeof(symbol_585)-1)), runtime);
 }
 
 void action_37(struct Runtime* runtime, struct Variables* variables) {
@@ -1932,14 +1955,14 @@ void action_37(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_namedWs;
     runtime->current_chunks = chunks;
-    action = lookup_action(variables, buffer_from_cstring(symbol_584, sizeof(symbol_584)-1));
+    action = lookup_action(variables, buffer_from_cstring(symbol_590, sizeof(symbol_590)-1));
     if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_585, sizeof(symbol_585)-1), 0, NULL);
-        run_action(lookup_action(variables, buffer_from_cstring(symbol_586, sizeof(symbol_586)-1)), runtime);
-        append_data(runtime->current_chunks, buffer_from_cstring(symbol_587, sizeof(symbol_587)-1), 0, NULL);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_591, sizeof(symbol_591)-1), 0, NULL);
+        run_action(lookup_action(variables, buffer_from_cstring(symbol_592, sizeof(symbol_592)-1)), runtime);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_593, sizeof(symbol_593)-1), 0, NULL);
     }
     runtime->current_chunks = last_chunks;
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_588, sizeof(symbol_588)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_594, sizeof(symbol_594)-1)), runtime);
 }
 
 void action_38(struct Runtime* runtime, struct Variables* variables) {
@@ -1951,17 +1974,17 @@ void action_38(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_592, sizeof(symbol_592)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_598, sizeof(symbol_598)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_593, sizeof(symbol_593)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_594, sizeof(symbol_594)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_595, sizeof(symbol_595)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_599, sizeof(symbol_599)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_600, sizeof(symbol_600)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_601, sizeof(symbol_601)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_596, sizeof(symbol_596)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_602, sizeof(symbol_602)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_597, sizeof(symbol_597)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_603, sizeof(symbol_603)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_598, sizeof(symbol_598)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_604, sizeof(symbol_604)-1), 0, NULL);
 }
 
 void action_39(struct Runtime* runtime, struct Variables* variables) {
@@ -1969,7 +1992,7 @@ void action_39(struct Runtime* runtime, struct Variables* variables) {
     struct Chunks* last_chunks;
     struct Action* action;
     fprintf(stderr, "debug: running action_39\n");
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_602, sizeof(symbol_602)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_608, sizeof(symbol_608)-1), 0, NULL);
 }
 
 void action_40(struct Runtime* runtime, struct Variables* variables) {
@@ -1981,17 +2004,17 @@ void action_40(struct Runtime* runtime, struct Variables* variables) {
     last_chunks = runtime->current_chunks;
     chunks = runtime->named_chunks_symbols;
     runtime->current_chunks = chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_604, sizeof(symbol_604)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_610, sizeof(symbol_610)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_605, sizeof(symbol_605)-1), 0, NULL);
-    run_action(lookup_action(variables, buffer_from_cstring(symbol_606, sizeof(symbol_606)-1)), runtime);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_607, sizeof(symbol_607)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_611, sizeof(symbol_611)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_612, sizeof(symbol_612)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_613, sizeof(symbol_613)-1), 0, NULL);
     runtime->current_chunks = last_chunks;
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_608, sizeof(symbol_608)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_614, sizeof(symbol_614)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_609, sizeof(symbol_609)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_615, sizeof(symbol_615)-1), 0, NULL);
     append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
-    append_data(runtime->current_chunks, buffer_from_cstring(symbol_610, sizeof(symbol_610)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_616, sizeof(symbol_616)-1), 0, NULL);
 }
 
 struct Action* rule_main(struct ParseState* parse_state) {
@@ -2090,11 +2113,11 @@ struct Action* rule_rule(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_name(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_318, sizeof(symbol_318)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_322, sizeof(symbol_322)-1), _);
         if (_) {
             _ = rule_space(parse_state);
             if (_) {
-                data = buffer_from_cstring(symbol_319, sizeof(symbol_319)-1);
+                data = buffer_from_cstring(symbol_323, sizeof(symbol_323)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2105,11 +2128,11 @@ struct Action* rule_rule(struct ParseState* parse_state) {
                     _ = rule_space(parse_state);
                     if (_) {
                         _ = rule_ors(parse_state);
-                        append_named_action(variables, buffer_from_cstring(symbol_320, sizeof(symbol_320)-1), _);
+                        append_named_action(variables, buffer_from_cstring(symbol_324, sizeof(symbol_324)-1), _);
                         if (_) {
                             _ = rule_space(parse_state);
                             if (_) {
-                                data = buffer_from_cstring(symbol_321, sizeof(symbol_321)-1);
+                                data = buffer_from_cstring(symbol_325, sizeof(symbol_325)-1);
                                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                     parse_state->pos += data->size;
                                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2148,7 +2171,7 @@ struct Action* rule_ors(struct ParseState* parse_state) {
     _ = rule_maybeorbar(parse_state);
     if (_) {
         _ = rule_orcase(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_347, sizeof(symbol_347)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_351, sizeof(symbol_351)-1), _);
         if (_) {
             star_variables = create_variables();
             star_start_pos = parse_state->pos;
@@ -2163,7 +2186,7 @@ struct Action* rule_ors(struct ParseState* parse_state) {
             }
             fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
             _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-            append_named_action(variables, buffer_from_cstring(symbol_348, sizeof(symbol_348)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_352, sizeof(symbol_352)-1), _);
             if (_) {
                 return create_action(action_4, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
@@ -2191,7 +2214,7 @@ struct Action* rule_restorcase(struct ParseState* parse_state) {
     _ = rule_orbar(parse_state);
     if (_) {
         _ = rule_orcase(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_352, sizeof(symbol_352)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_356, sizeof(symbol_356)-1), _);
         if (_) {
             return create_action(action_5, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2244,7 +2267,7 @@ struct Action* rule_orbar(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_354, sizeof(symbol_354)-1);
+        data = buffer_from_cstring(symbol_358, sizeof(symbol_358)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2275,7 +2298,7 @@ struct Action* rule_orcase(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchAnd(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_355, sizeof(symbol_355)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_359, sizeof(symbol_359)-1), _);
     if (_) {
         return create_action(action_7, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -2301,10 +2324,10 @@ struct Action* rule_matchAnd(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_matchExpr(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_360, sizeof(symbol_360)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_364, sizeof(symbol_364)-1), _);
         if (_) {
             _ = rule_matchAnd(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_361, sizeof(symbol_361)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_365, sizeof(symbol_365)-1), _);
             if (_) {
                 return create_action(action_8, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
@@ -2314,7 +2337,7 @@ struct Action* rule_matchAnd(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_action(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_366, sizeof(symbol_366)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_370, sizeof(symbol_370)-1), _);
     if (_) {
         return create_action(action_9, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -2337,7 +2360,7 @@ struct Action* rule_matchExpr(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_368, sizeof(symbol_368)-1);
+    data = buffer_from_cstring(symbol_372, sizeof(symbol_372)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2346,7 +2369,7 @@ struct Action* rule_matchExpr(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_matchExprPrimitive(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_369, sizeof(symbol_369)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_373, sizeof(symbol_373)-1), _);
         if (_) {
             return create_action(action_10, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2355,10 +2378,10 @@ struct Action* rule_matchExpr(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchExprRepeat(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_378, sizeof(symbol_378)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_382, sizeof(symbol_382)-1), _);
     if (_) {
         _ = rule_matchAssign(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_379, sizeof(symbol_379)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_383, sizeof(symbol_383)-1), _);
         if (_) {
             return create_action(action_11, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2382,7 +2405,7 @@ struct Action* rule_matchAssign(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_382, sizeof(symbol_382)-1);
+    data = buffer_from_cstring(symbol_386, sizeof(symbol_386)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2391,7 +2414,7 @@ struct Action* rule_matchAssign(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_nameAsSymbol(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_383, sizeof(symbol_383)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_387, sizeof(symbol_387)-1), _);
         if (_) {
             return create_action(action_12, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2420,9 +2443,9 @@ struct Action* rule_matchExprRepeat(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchExprPrimitive(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_387, sizeof(symbol_387)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_391, sizeof(symbol_391)-1), _);
     if (_) {
-        data = buffer_from_cstring(symbol_388, sizeof(symbol_388)-1);
+        data = buffer_from_cstring(symbol_392, sizeof(symbol_392)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2437,7 +2460,7 @@ struct Action* rule_matchExprRepeat(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_matchExprPrimitive(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_402, sizeof(symbol_402)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_406, sizeof(symbol_406)-1), _);
     if (_) {
         return create_action(action_15, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -2461,14 +2484,14 @@ struct Action* rule_matchExprPrimitive(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_name(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_404, sizeof(symbol_404)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_408, sizeof(symbol_408)-1), _);
     if (_) {
         return create_action(action_16, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_408, sizeof(symbol_408)-1);
+    data = buffer_from_cstring(symbol_412, sizeof(symbol_412)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2482,7 +2505,7 @@ struct Action* rule_matchExprPrimitive(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_charstring(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_415, sizeof(symbol_415)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_419, sizeof(symbol_419)-1), _);
     if (_) {
         return create_action(action_18, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -2507,7 +2530,7 @@ struct Action* rule_action(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_425, sizeof(symbol_425)-1);
+        data = buffer_from_cstring(symbol_429, sizeof(symbol_429)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2517,7 +2540,7 @@ struct Action* rule_action(struct ParseState* parse_state) {
         if (_) {
             _ = rule_space(parse_state);
             if (_) {
-                data = buffer_from_cstring(symbol_426, sizeof(symbol_426)-1);
+                data = buffer_from_cstring(symbol_430, sizeof(symbol_430)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2538,11 +2561,11 @@ struct Action* rule_action(struct ParseState* parse_state) {
                     }
                     fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
                     _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-                    append_named_action(variables, buffer_from_cstring(symbol_427, sizeof(symbol_427)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_431, sizeof(symbol_431)-1), _);
                     if (_) {
                         _ = rule_space(parse_state);
                         if (_) {
-                            data = buffer_from_cstring(symbol_428, sizeof(symbol_428)-1);
+                            data = buffer_from_cstring(symbol_432, sizeof(symbol_432)-1);
                             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                 parse_state->pos += data->size;
                                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2583,7 +2606,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_442, sizeof(symbol_442)-1);
+        data = buffer_from_cstring(symbol_446, sizeof(symbol_446)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2592,9 +2615,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_nameAsSymbol(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_443, sizeof(symbol_443)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_447, sizeof(symbol_447)-1), _);
             if (_) {
-                data = buffer_from_cstring(symbol_444, sizeof(symbol_444)-1);
+                data = buffer_from_cstring(symbol_448, sizeof(symbol_448)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2615,11 +2638,11 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                     }
                     fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
                     _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-                    append_named_action(variables, buffer_from_cstring(symbol_445, sizeof(symbol_445)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_449, sizeof(symbol_449)-1), _);
                     if (_) {
                         _ = rule_space(parse_state);
                         if (_) {
-                            data = buffer_from_cstring(symbol_446, sizeof(symbol_446)-1);
+                            data = buffer_from_cstring(symbol_450, sizeof(symbol_450)-1);
                             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                 parse_state->pos += data->size;
                                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2640,7 +2663,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_453, sizeof(symbol_453)-1);
+        data = buffer_from_cstring(symbol_457, sizeof(symbol_457)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2649,11 +2672,11 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_chunkName(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_454, sizeof(symbol_454)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_458, sizeof(symbol_458)-1), _);
             if (_) {
                 _ = rule_space(parse_state);
                 if (_) {
-                    data = buffer_from_cstring(symbol_455, sizeof(symbol_455)-1);
+                    data = buffer_from_cstring(symbol_459, sizeof(symbol_459)-1);
                     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                         parse_state->pos += data->size;
                         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2674,11 +2697,11 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                         }
                         fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
                         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-                        append_named_action(variables, buffer_from_cstring(symbol_456, sizeof(symbol_456)-1), _);
+                        append_named_action(variables, buffer_from_cstring(symbol_460, sizeof(symbol_460)-1), _);
                         if (_) {
                             _ = rule_space(parse_state);
                             if (_) {
-                                data = buffer_from_cstring(symbol_457, sizeof(symbol_457)-1);
+                                data = buffer_from_cstring(symbol_461, sizeof(symbol_461)-1);
                                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                     parse_state->pos += data->size;
                                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2700,7 +2723,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_465, sizeof(symbol_465)-1);
+        data = buffer_from_cstring(symbol_469, sizeof(symbol_469)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2709,7 +2732,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_chunkName(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_466, sizeof(symbol_466)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_470, sizeof(symbol_470)-1), _);
             if (_) {
                 return create_action(action_23, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
             }
@@ -2721,7 +2744,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_expr(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_472, sizeof(symbol_472)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_476, sizeof(symbol_476)-1), _);
         if (_) {
             return create_action(action_24, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2732,7 +2755,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_nameAsSymbol(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_476, sizeof(symbol_476)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_480, sizeof(symbol_480)-1), _);
         if (_) {
             return create_action(action_25, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2743,7 +2766,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_placeholder(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_480, sizeof(symbol_480)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_484, sizeof(symbol_484)-1), _);
         if (_) {
             return create_action(action_26, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2754,7 +2777,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     _ = rule_space(parse_state);
     if (_) {
         _ = rule_string(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_490, sizeof(symbol_490)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_496, sizeof(symbol_496)-1), _);
         if (_) {
             return create_action(action_27, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -2764,7 +2787,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_494, sizeof(symbol_494)-1);
+        data = buffer_from_cstring(symbol_500, sizeof(symbol_500)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2773,9 +2796,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
         }
         if (_) {
             _ = rule_name(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_495, sizeof(symbol_495)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_501, sizeof(symbol_501)-1), _);
             if (_) {
-                data = buffer_from_cstring(symbol_496, sizeof(symbol_496)-1);
+                data = buffer_from_cstring(symbol_502, sizeof(symbol_502)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2784,9 +2807,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                 }
                 if (_) {
                     _ = rule_wvar(parse_state);
-                    append_named_action(variables, buffer_from_cstring(symbol_497, sizeof(symbol_497)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_503, sizeof(symbol_503)-1), _);
                     if (_) {
-                        data = buffer_from_cstring(symbol_498, sizeof(symbol_498)-1);
+                        data = buffer_from_cstring(symbol_504, sizeof(symbol_504)-1);
                         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                             parse_state->pos += data->size;
                             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2795,9 +2818,9 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
                         }
                         if (_) {
                             _ = rule_actionPrimitiveExpression(parse_state);
-                            append_named_action(variables, buffer_from_cstring(symbol_499, sizeof(symbol_499)-1), _);
+                            append_named_action(variables, buffer_from_cstring(symbol_505, sizeof(symbol_505)-1), _);
                             if (_) {
-                                data = buffer_from_cstring(symbol_500, sizeof(symbol_500)-1);
+                                data = buffer_from_cstring(symbol_506, sizeof(symbol_506)-1);
                                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                     parse_state->pos += data->size;
                                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2819,7 +2842,7 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
     variables = create_variables();
     _ = rule_space(parse_state);
     if (_) {
-        data = buffer_from_cstring(symbol_512, sizeof(symbol_512)-1);
+        data = buffer_from_cstring(symbol_518, sizeof(symbol_518)-1);
         if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
             parse_state->pos += data->size;
             _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2840,11 +2863,11 @@ struct Action* rule_actionexpr(struct ParseState* parse_state) {
             }
             fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
             _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-            append_named_action(variables, buffer_from_cstring(symbol_513, sizeof(symbol_513)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_519, sizeof(symbol_519)-1), _);
             if (_) {
                 _ = rule_space(parse_state);
                 if (_) {
-                    data = buffer_from_cstring(symbol_514, sizeof(symbol_514)-1);
+                    data = buffer_from_cstring(symbol_520, sizeof(symbol_520)-1);
                     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                         parse_state->pos += data->size;
                         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2878,7 +2901,7 @@ struct Action* rule_chunkName(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_name(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_518, sizeof(symbol_518)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_524, sizeof(symbol_524)-1), _);
     if (_) {
         return create_action(action_30, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -2902,7 +2925,7 @@ struct Action* rule_actionPrimitiveExpression(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_dotname(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_524, sizeof(symbol_524)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_530, sizeof(symbol_530)-1), _);
     if (_) {
         return create_action(action_31, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -2932,7 +2955,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_526, sizeof(symbol_526)-1);
+    data = buffer_from_cstring(symbol_532, sizeof(symbol_532)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2945,7 +2968,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_527, sizeof(symbol_527)-1);
+    data = buffer_from_cstring(symbol_533, sizeof(symbol_533)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2958,7 +2981,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_528, sizeof(symbol_528)-1);
+    data = buffer_from_cstring(symbol_534, sizeof(symbol_534)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2971,7 +2994,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_529, sizeof(symbol_529)-1);
+    data = buffer_from_cstring(symbol_535, sizeof(symbol_535)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2984,7 +3007,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_530, sizeof(symbol_530)-1);
+    data = buffer_from_cstring(symbol_536, sizeof(symbol_536)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -2997,7 +3020,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_531, sizeof(symbol_531)-1);
+    data = buffer_from_cstring(symbol_537, sizeof(symbol_537)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3010,7 +3033,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_532, sizeof(symbol_532)-1);
+    data = buffer_from_cstring(symbol_538, sizeof(symbol_538)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3023,7 +3046,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_533, sizeof(symbol_533)-1);
+    data = buffer_from_cstring(symbol_539, sizeof(symbol_539)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3036,7 +3059,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_534, sizeof(symbol_534)-1);
+    data = buffer_from_cstring(symbol_540, sizeof(symbol_540)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3049,7 +3072,7 @@ struct Action* rule_digit(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_535, sizeof(symbol_535)-1);
+    data = buffer_from_cstring(symbol_541, sizeof(symbol_541)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3078,7 +3101,7 @@ struct Action* rule_placeholder(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_536, sizeof(symbol_536)-1);
+    data = buffer_from_cstring(symbol_542, sizeof(symbol_542)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3089,9 +3112,9 @@ struct Action* rule_placeholder(struct ParseState* parse_state) {
         _ = rule_space(parse_state);
         if (_) {
             _ = rule_string(parse_state);
-            append_named_action(variables, buffer_from_cstring(symbol_537, sizeof(symbol_537)-1), _);
+            append_named_action(variables, buffer_from_cstring(symbol_543, sizeof(symbol_543)-1), _);
             if (_) {
-                data = buffer_from_cstring(symbol_538, sizeof(symbol_538)-1);
+                data = buffer_from_cstring(symbol_544, sizeof(symbol_544)-1);
                 if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                     parse_state->pos += data->size;
                     _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3100,11 +3123,11 @@ struct Action* rule_placeholder(struct ParseState* parse_state) {
                 }
                 if (_) {
                     _ = rule_expr(parse_state);
-                    append_named_action(variables, buffer_from_cstring(symbol_539, sizeof(symbol_539)-1), _);
+                    append_named_action(variables, buffer_from_cstring(symbol_545, sizeof(symbol_545)-1), _);
                     if (_) {
                         _ = rule_space(parse_state);
                         if (_) {
-                            data = buffer_from_cstring(symbol_540, sizeof(symbol_540)-1);
+                            data = buffer_from_cstring(symbol_546, sizeof(symbol_546)-1);
                             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                                 parse_state->pos += data->size;
                                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3140,14 +3163,14 @@ struct Action* rule_expr(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_wvar(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_546, sizeof(symbol_546)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_552, sizeof(symbol_552)-1), _);
     if (_) {
         return create_action(action_33, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_552, sizeof(symbol_552)-1);
+    data = buffer_from_cstring(symbol_558, sizeof(symbol_558)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3156,9 +3179,9 @@ struct Action* rule_expr(struct ParseState* parse_state) {
     }
     if (_) {
         _ = rule_wvar(parse_state);
-        append_named_action(variables, buffer_from_cstring(symbol_553, sizeof(symbol_553)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_559, sizeof(symbol_559)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_554, sizeof(symbol_554)-1);
+            data = buffer_from_cstring(symbol_560, sizeof(symbol_560)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3167,9 +3190,9 @@ struct Action* rule_expr(struct ParseState* parse_state) {
             }
             if (_) {
                 _ = rule_dotname(parse_state);
-                append_named_action(variables, buffer_from_cstring(symbol_555, sizeof(symbol_555)-1), _);
+                append_named_action(variables, buffer_from_cstring(symbol_561, sizeof(symbol_561)-1), _);
                 if (_) {
-                    data = buffer_from_cstring(symbol_556, sizeof(symbol_556)-1);
+                    data = buffer_from_cstring(symbol_562, sizeof(symbol_562)-1);
                     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                         parse_state->pos += data->size;
                         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3202,7 +3225,7 @@ struct Action* rule_string(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_564, sizeof(symbol_564)-1);
+    data = buffer_from_cstring(symbol_570, sizeof(symbol_570)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3223,9 +3246,9 @@ struct Action* rule_string(struct ParseState* parse_state) {
         }
         fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_565, sizeof(symbol_565)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_571, sizeof(symbol_571)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_566, sizeof(symbol_566)-1);
+            data = buffer_from_cstring(symbol_572, sizeof(symbol_572)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3257,7 +3280,7 @@ struct Action* rule_dotname(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_nameAsSymbol(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_574, sizeof(symbol_574)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_580, sizeof(symbol_580)-1), _);
     if (_) {
         star_variables = create_variables();
         star_start_pos = parse_state->pos;
@@ -3272,7 +3295,7 @@ struct Action* rule_dotname(struct ParseState* parse_state) {
         }
         fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_575, sizeof(symbol_575)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_581, sizeof(symbol_581)-1), _);
         if (_) {
             return create_action(action_36, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
         }
@@ -3296,7 +3319,7 @@ struct Action* rule_nextname(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_580, sizeof(symbol_580)-1);
+    data = buffer_from_cstring(symbol_586, sizeof(symbol_586)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3328,7 +3351,7 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_581, sizeof(symbol_581)-1);
+    data = buffer_from_cstring(symbol_587, sizeof(symbol_587)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3342,9 +3365,9 @@ struct Action* rule_wvar(struct ParseState* parse_state) {
         } else {
             _ = NULL;
         }
-        append_named_action(variables, buffer_from_cstring(symbol_582, sizeof(symbol_582)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_588, sizeof(symbol_588)-1), _);
         if (_) {
-            data = buffer_from_cstring(symbol_583, sizeof(symbol_583)-1);
+            data = buffer_from_cstring(symbol_589, sizeof(symbol_589)-1);
             if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
                 parse_state->pos += data->size;
                 _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3375,7 +3398,7 @@ struct Action* rule_stringinner(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_589, sizeof(symbol_589)-1);
+    data = buffer_from_cstring(symbol_595, sizeof(symbol_595)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3426,7 +3449,7 @@ struct Action* rule_stringend(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_590, sizeof(symbol_590)-1);
+    data = buffer_from_cstring(symbol_596, sizeof(symbol_596)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3470,7 +3493,7 @@ struct Action* rule_charstring(struct ParseState* parse_state) {
         }
         fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
         _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
-        append_named_action(variables, buffer_from_cstring(symbol_591, sizeof(symbol_591)-1), _);
+        append_named_action(variables, buffer_from_cstring(symbol_597, sizeof(symbol_597)-1), _);
         if (_) {
             _ = rule_quote(parse_state);
             if (_) {
@@ -3497,7 +3520,7 @@ struct Action* rule_quote(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_599, sizeof(symbol_599)-1);
+    data = buffer_from_cstring(symbol_605, sizeof(symbol_605)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3526,7 +3549,7 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_600, sizeof(symbol_600)-1);
+    data = buffer_from_cstring(symbol_606, sizeof(symbol_606)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3539,7 +3562,7 @@ struct Action* rule_innercharstring(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_601, sizeof(symbol_601)-1);
+    data = buffer_from_cstring(symbol_607, sizeof(symbol_607)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3591,7 +3614,7 @@ struct Action* rule_nameAsSymbol(struct ParseState* parse_state) {
     action_start_pos = parse_state->pos;
     variables = create_variables();
     _ = rule_name(parse_state);
-    append_named_action(variables, buffer_from_cstring(symbol_603, sizeof(symbol_603)-1), _);
+    append_named_action(variables, buffer_from_cstring(symbol_609, sizeof(symbol_609)-1), _);
     if (_) {
         return create_action(action_40, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
     }
@@ -3652,7 +3675,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_611, sizeof(symbol_611)-1);
+    data = buffer_from_cstring(symbol_617, sizeof(symbol_617)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3665,7 +3688,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_612, sizeof(symbol_612)-1);
+    data = buffer_from_cstring(symbol_618, sizeof(symbol_618)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3678,7 +3701,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_613, sizeof(symbol_613)-1);
+    data = buffer_from_cstring(symbol_619, sizeof(symbol_619)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3691,7 +3714,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_614, sizeof(symbol_614)-1);
+    data = buffer_from_cstring(symbol_620, sizeof(symbol_620)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3704,7 +3727,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_615, sizeof(symbol_615)-1);
+    data = buffer_from_cstring(symbol_621, sizeof(symbol_621)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3717,7 +3740,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_616, sizeof(symbol_616)-1);
+    data = buffer_from_cstring(symbol_622, sizeof(symbol_622)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3730,7 +3753,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_617, sizeof(symbol_617)-1);
+    data = buffer_from_cstring(symbol_623, sizeof(symbol_623)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3743,7 +3766,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_618, sizeof(symbol_618)-1);
+    data = buffer_from_cstring(symbol_624, sizeof(symbol_624)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3756,7 +3779,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_619, sizeof(symbol_619)-1);
+    data = buffer_from_cstring(symbol_625, sizeof(symbol_625)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3769,7 +3792,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_620, sizeof(symbol_620)-1);
+    data = buffer_from_cstring(symbol_626, sizeof(symbol_626)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3782,7 +3805,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_621, sizeof(symbol_621)-1);
+    data = buffer_from_cstring(symbol_627, sizeof(symbol_627)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3795,7 +3818,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_622, sizeof(symbol_622)-1);
+    data = buffer_from_cstring(symbol_628, sizeof(symbol_628)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3808,7 +3831,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_623, sizeof(symbol_623)-1);
+    data = buffer_from_cstring(symbol_629, sizeof(symbol_629)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3821,7 +3844,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_624, sizeof(symbol_624)-1);
+    data = buffer_from_cstring(symbol_630, sizeof(symbol_630)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3834,7 +3857,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_625, sizeof(symbol_625)-1);
+    data = buffer_from_cstring(symbol_631, sizeof(symbol_631)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3847,7 +3870,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_626, sizeof(symbol_626)-1);
+    data = buffer_from_cstring(symbol_632, sizeof(symbol_632)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3860,7 +3883,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_627, sizeof(symbol_627)-1);
+    data = buffer_from_cstring(symbol_633, sizeof(symbol_633)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3873,7 +3896,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_628, sizeof(symbol_628)-1);
+    data = buffer_from_cstring(symbol_634, sizeof(symbol_634)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3886,7 +3909,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_629, sizeof(symbol_629)-1);
+    data = buffer_from_cstring(symbol_635, sizeof(symbol_635)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3899,7 +3922,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_630, sizeof(symbol_630)-1);
+    data = buffer_from_cstring(symbol_636, sizeof(symbol_636)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3912,7 +3935,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_631, sizeof(symbol_631)-1);
+    data = buffer_from_cstring(symbol_637, sizeof(symbol_637)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3925,7 +3948,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_632, sizeof(symbol_632)-1);
+    data = buffer_from_cstring(symbol_638, sizeof(symbol_638)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3938,7 +3961,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_633, sizeof(symbol_633)-1);
+    data = buffer_from_cstring(symbol_639, sizeof(symbol_639)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3951,7 +3974,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_634, sizeof(symbol_634)-1);
+    data = buffer_from_cstring(symbol_640, sizeof(symbol_640)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3964,7 +3987,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_635, sizeof(symbol_635)-1);
+    data = buffer_from_cstring(symbol_641, sizeof(symbol_641)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3977,7 +4000,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_636, sizeof(symbol_636)-1);
+    data = buffer_from_cstring(symbol_642, sizeof(symbol_642)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -3990,7 +4013,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_637, sizeof(symbol_637)-1);
+    data = buffer_from_cstring(symbol_643, sizeof(symbol_643)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4003,7 +4026,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_638, sizeof(symbol_638)-1);
+    data = buffer_from_cstring(symbol_644, sizeof(symbol_644)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4016,7 +4039,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_639, sizeof(symbol_639)-1);
+    data = buffer_from_cstring(symbol_645, sizeof(symbol_645)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4029,7 +4052,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_640, sizeof(symbol_640)-1);
+    data = buffer_from_cstring(symbol_646, sizeof(symbol_646)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4042,7 +4065,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_641, sizeof(symbol_641)-1);
+    data = buffer_from_cstring(symbol_647, sizeof(symbol_647)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4055,7 +4078,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_642, sizeof(symbol_642)-1);
+    data = buffer_from_cstring(symbol_648, sizeof(symbol_648)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4068,7 +4091,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_643, sizeof(symbol_643)-1);
+    data = buffer_from_cstring(symbol_649, sizeof(symbol_649)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4081,7 +4104,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_644, sizeof(symbol_644)-1);
+    data = buffer_from_cstring(symbol_650, sizeof(symbol_650)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4094,7 +4117,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_645, sizeof(symbol_645)-1);
+    data = buffer_from_cstring(symbol_651, sizeof(symbol_651)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4107,7 +4130,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_646, sizeof(symbol_646)-1);
+    data = buffer_from_cstring(symbol_652, sizeof(symbol_652)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4120,7 +4143,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_647, sizeof(symbol_647)-1);
+    data = buffer_from_cstring(symbol_653, sizeof(symbol_653)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4133,7 +4156,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_648, sizeof(symbol_648)-1);
+    data = buffer_from_cstring(symbol_654, sizeof(symbol_654)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4146,7 +4169,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_649, sizeof(symbol_649)-1);
+    data = buffer_from_cstring(symbol_655, sizeof(symbol_655)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4159,7 +4182,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_650, sizeof(symbol_650)-1);
+    data = buffer_from_cstring(symbol_656, sizeof(symbol_656)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4172,7 +4195,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_651, sizeof(symbol_651)-1);
+    data = buffer_from_cstring(symbol_657, sizeof(symbol_657)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4185,7 +4208,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_652, sizeof(symbol_652)-1);
+    data = buffer_from_cstring(symbol_658, sizeof(symbol_658)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4198,7 +4221,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_653, sizeof(symbol_653)-1);
+    data = buffer_from_cstring(symbol_659, sizeof(symbol_659)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4211,7 +4234,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_654, sizeof(symbol_654)-1);
+    data = buffer_from_cstring(symbol_660, sizeof(symbol_660)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4224,7 +4247,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_655, sizeof(symbol_655)-1);
+    data = buffer_from_cstring(symbol_661, sizeof(symbol_661)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4237,7 +4260,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_656, sizeof(symbol_656)-1);
+    data = buffer_from_cstring(symbol_662, sizeof(symbol_662)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4250,7 +4273,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_657, sizeof(symbol_657)-1);
+    data = buffer_from_cstring(symbol_663, sizeof(symbol_663)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4263,7 +4286,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_658, sizeof(symbol_658)-1);
+    data = buffer_from_cstring(symbol_664, sizeof(symbol_664)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4276,7 +4299,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_659, sizeof(symbol_659)-1);
+    data = buffer_from_cstring(symbol_665, sizeof(symbol_665)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4289,7 +4312,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_660, sizeof(symbol_660)-1);
+    data = buffer_from_cstring(symbol_666, sizeof(symbol_666)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4302,7 +4325,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_661, sizeof(symbol_661)-1);
+    data = buffer_from_cstring(symbol_667, sizeof(symbol_667)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4315,7 +4338,7 @@ struct Action* rule_char(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_662, sizeof(symbol_662)-1);
+    data = buffer_from_cstring(symbol_668, sizeof(symbol_668)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4379,7 +4402,7 @@ struct Action* rule_spacechar(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_663, sizeof(symbol_663)-1);
+    data = buffer_from_cstring(symbol_669, sizeof(symbol_669)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
@@ -4392,7 +4415,7 @@ struct Action* rule_spacechar(struct ParseState* parse_state) {
     parse_state->pos = or_backtrack_pos;
     action_start_pos = parse_state->pos;
     variables = create_variables();
-    data = buffer_from_cstring(symbol_664, sizeof(symbol_664)-1);
+    data = buffer_from_cstring(symbol_670, sizeof(symbol_670)-1);
     if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
         parse_state->pos += data->size;
         _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 8b6aa9b..4a816a8 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -262,6 +262,10 @@ file = rule*:xs space !. -> {
         "return value + amount;\n"
     < "}\n"
     "\n"
+    "unsigned int max(unsigned int a, unsigned int b) {\n" >
+        "return a > b ? a : b;\n"
+    < "}\n"
+    "\n"
     "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n" >
         "fprintf(stderr, \"debug: render chunks\\n\");\n"
         "if (chunks) {\n" >
@@ -485,14 +489,17 @@ actionexpr =
     }
     | space placeholder:x -> {
         #inc(W[1] 1)
+        >definitions {
+            "void placeholder_" W[1] "(struct Runtime* runtime, struct Variables* variables);"
+        }
         >placeholders {
             "void placeholder_" W[1] "(struct Runtime* runtime, struct Variables* variables) {" >
                 x
             < "}\n"
             "\n"
         }
-        "chunks = create_chunks()\n"
-        "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_" W[1] ", variables, '', 0, 0))\n"
+        "chunks = create_chunks();\n"
+        "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_" W[1] ", variables, NULL, 0, 0));\n"
         "append_data(runtime->current_chunks, NULL, 0, chunks);\n"
     }
     | space string:x -> {

commit 5959f4e6456423251f808e6199c66eb3bd971648
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 12:11:27 2025 +0100

    Replace rlmeta2.py with rlmeta2.c!

diff --git a/08_translate_to_c/.gitignore b/08_translate_to_c/.gitignore
index 21bd4e6..c1cc0ac 100644
--- a/08_translate_to_c/.gitignore
+++ b/08_translate_to_c/.gitignore
@@ -1,5 +1,8 @@
-table.py
-rlmeta2_meta.py
+rlmeta2
 rlmeta2_meta.c
 rlmeta2_meta
+
+table
+table.c
+
 experiments
diff --git a/08_translate_to_c/accept.sh b/08_translate_to_c/accept.sh
index 7e120b6..9480912 100755
--- a/08_translate_to_c/accept.sh
+++ b/08_translate_to_c/accept.sh
@@ -4,6 +4,6 @@ set -e
 
 cd "$(dirname "$0")"
 
-mv rlmeta2_meta.py rlmeta2.py
+mv rlmeta2_meta.c rlmeta2.c
 
 ./test.sh
diff --git a/08_translate_to_c/rlmeta2.c b/08_translate_to_c/rlmeta2.c
new file mode 100644
index 0000000..40533be
--- /dev/null
+++ b/08_translate_to_c/rlmeta2.c
@@ -0,0 +1,4435 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+struct Variables;
+
+struct Buffer {
+    char* buffer;
+    unsigned int size;
+};
+
+struct ParseState {
+    struct Buffer* input_buffer;
+    unsigned int pos;
+};
+
+struct Runtime {
+    struct Chunks* main_chunks;
+    struct Chunks* named_chunks_namedChunks;
+    struct Chunks* named_chunks_namedWs;
+    struct Chunks* named_chunks_symbols;
+    struct Chunks* named_chunks_definitions;
+    struct Chunks* named_chunks_actions;
+    struct Chunks* named_chunks_placeholders;
+    struct Chunks* current_chunks;
+    unsigned int W_0;
+    unsigned int W_1;
+    unsigned int W_2;
+    struct Placeholders* placeholders;
+};
+
+struct Action {
+    void (*function)(struct Runtime*, struct Variables*);
+    struct Variables* variables;
+    struct Buffer* input_buffer;
+    unsigned int start;
+    unsigned int end;
+    unsigned int len;
+};
+
+struct Variables {
+    struct Variable* pre_first;
+    struct Variable* last;
+};
+
+struct Variable {
+    struct Variable* next;
+    struct Buffer* name;
+    struct Action* action;
+};
+
+struct Chunks {
+    struct Chunk* pre_first;
+    struct Chunk* last;
+};
+
+struct Chunk {
+    struct Chunk* next;
+    struct Buffer* data;
+    struct Chunks* chunks;
+    int indentation_delta;
+};
+
+struct Placeholders {
+    struct Placeholder* pre_first;
+    struct Placeholder* last;
+};
+
+struct Placeholder {
+    struct Placeholder* next;
+    struct Chunks* chunks;
+    struct Action* action;
+};
+
+static char* arena;
+static unsigned int arena_limit;
+static unsigned int arena_pos;
+
+void* allocate(size_t size) {
+    void* pointer = arena + arena_pos;
+    arena_pos += size;
+    if (arena_pos >= arena_limit) {
+        fprintf(stderr, "ERROR: out of memory");
+        exit(1);
+    }
+    return pointer;
+}
+
+struct ParseState* create_parse_state_from_stdin() {
+    char* pos;
+    struct ParseState* parse_state = allocate(sizeof(struct ParseState));
+    parse_state->input_buffer = allocate(sizeof(struct Buffer));
+    parse_state->input_buffer->buffer = allocate(1);
+    parse_state->input_buffer->size = 1;
+    parse_state->pos = 0;
+    pos = parse_state->input_buffer->buffer;
+    while (fgets(pos, 2, stdin)) {
+        pos = allocate(1);
+        parse_state->input_buffer->size++;
+    }
+    parse_state->input_buffer->size--;
+    fprintf(stderr, "debug: stdin data memory = %p\n", parse_state->input_buffer->buffer);
+    return parse_state;
+}
+
+struct Chunks* create_chunks() {
+    struct Chunks* chunks = allocate(sizeof(struct Chunks));
+    chunks->pre_first = allocate(sizeof(struct Chunk));
+    chunks->pre_first->next = NULL;
+    chunks->last = chunks->pre_first;
+    return chunks;
+}
+
+struct Placeholders* create_placeholders() {
+    struct Placeholders* placeholders = allocate(sizeof(struct Placeholders));
+    placeholders->pre_first = allocate(sizeof(struct Placeholder));
+    placeholders->pre_first->next = NULL;
+    placeholders->last = placeholders->pre_first;
+    return placeholders;
+}
+
+struct Runtime* create_runtime() {
+    struct Runtime* runtime = allocate(sizeof(struct Runtime));
+    runtime->main_chunks = create_chunks();
+    runtime->current_chunks = runtime->main_chunks;
+    runtime->placeholders = create_placeholders();
+    return runtime;
+}
+
+struct Action* create_action(void (*function)(struct Runtime*, struct Variables*), struct Variables* variables, struct Buffer* input_buffer, unsigned int start, unsigned int end) {
+    struct Action* action = allocate(sizeof(struct Action));
+    action->function = function;
+    action->variables = variables;
+    action->input_buffer = input_buffer;
+    action->start = start;
+    action->end = end;
+    action->len = end-start;
+    fprintf(stderr, "debug: action [start=%d] [end=%d]\n", action->start, action->end);
+    return action;
+}
+
+struct Variables* create_variables() {
+    struct Variables* variables = allocate(sizeof(struct Variables));
+    variables->pre_first = allocate(sizeof(struct Variable));
+    variables->pre_first->next = NULL;
+    variables->last = variables->pre_first;
+    return variables;
+}
+
+void append_data(struct Chunks* chunks, struct Buffer* data, int indentation_delta, struct Chunks* sub_chunks) {
+    struct Chunk* chunk = allocate(sizeof(struct Chunk));
+    chunk->next = NULL;
+    chunk->data = data;
+    chunk->chunks = sub_chunks;
+    chunk->indentation_delta = indentation_delta;
+    chunks->last->next = chunk;
+    chunks->last = chunk;
+    fprintf(stderr, "debug: append chunk = %p\n", chunk);
+    if (chunk->data) {
+        fprintf(stderr, "  data = ");
+        for (int i=0; i<chunk->data->size; i++) {
+            fprintf(stderr, "%c", chunk->data->buffer[i]);
+        }
+        fprintf(stderr, "\n");
+    }
+}
+
+struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {
+    struct Buffer* buffer = allocate(sizeof(struct Buffer));
+    buffer->buffer = data->buffer;
+    buffer->size = end-start;
+    buffer->buffer += start;
+    return buffer;
+}
+
+struct Buffer* buffer_from_cstring(char* data, unsigned int size) {
+    struct Buffer* buffer = allocate(sizeof(struct Buffer));
+    buffer->buffer = data;
+    buffer->size = size;
+    return buffer;
+}
+
+struct Buffer* buffer_from_integer(unsigned int value) {
+    struct Buffer* buffer = allocate(sizeof(struct Buffer));
+    buffer->buffer = allocate(20);
+    sprintf(buffer->buffer, "%d", value);
+    buffer->size = strlen(buffer->buffer);
+    return buffer;
+}
+
+void run_action(struct Action* action, struct Runtime* runtime) {
+    if (action->function) {
+        action->function(runtime, action->variables);
+    } else {
+        if (action->variables) {
+            fprintf(stderr, "debug_run_action variables\n");
+            struct Variable* variable = action->variables->pre_first->next;
+            while (variable) {
+                run_action(variable->action, runtime);
+                variable = variable->next;
+            }
+        } else {
+            fprintf(stderr, "debug_run_action else\n");
+            append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);
+        }
+    }
+}
+
+int compare_buffers(struct Buffer* b1, struct Buffer* b2) {
+    if (b1->size != b2->size) {
+        return 0;
+    }
+    for (int i=0; i<b1->size; i++) {
+        if (b1->buffer[i] != b2->buffer[i]) {
+            return 0;
+        }
+    }
+    return 1;}
+
+int seen(struct Chunks* chunks, struct Buffer* data) {
+    struct Chunk* chunk = chunks->pre_first->next;
+    while (chunk) {
+        if (compare_buffers(chunk->data, data)) {
+            return 1;
+        }
+        chunk = chunk->next;
+    }
+    return 0;
+}
+
+void append_named_action(struct Variables* variables, struct Buffer* name, struct Action* action) {
+    struct Variable* next_variable = allocate(sizeof(struct Variable));
+    next_variable->next = NULL;
+    next_variable->name = name;
+    next_variable->action = action;
+    variables->last->next = next_variable;
+    variables->last = next_variable;
+}
+
+struct Action* lookup_action(struct Variables* variables, struct Buffer* name_to_look_for) {
+    struct Variable* variable = variables->pre_first->next;
+    while (variable) {
+        if (compare_buffers(variable->name, name_to_look_for)) {
+            fprintf(stderr, "debug: found action %p\n", variable->action);
+            return variable->action;
+        } else {
+            variable = variable->next;
+        }
+    }
+    fprintf(stderr, "ERROR: variable not found");
+    exit(1);
+}
+
+void append_placeholder(struct Placeholders* placeholders, struct Chunks* chunks, struct Action* action) {
+    struct Placeholder* next_placeholder = allocate(sizeof(struct Placeholder));
+    next_placeholder->next = NULL;
+    next_placeholder->chunks = chunks;
+    next_placeholder->action = action;
+    placeholders->last->next = next_placeholder;
+    placeholders->last = next_placeholder;
+}
+
+unsigned int inc(unsigned int value, unsigned int amount) {
+    return value + amount;
+}
+
+void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {
+    fprintf(stderr, "debug: render chunks\n");
+    if (chunks) {
+        struct Chunk* chunk = chunks->pre_first->next;
+        while (chunk) {
+            *indent += chunk->indentation_delta;
+            if (chunk->data) {
+                fprintf(stderr, "debug: chunk data memory = %p\n", chunk->data->buffer);
+                fprintf(stderr, "debug: arena offset      = %u\n", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));
+                for (int i=0; i<chunk->data->size; i++) {
+                    if (*last_char == '\n') {
+                        for (int j=0; j<*indent; j++) {
+                            printf("    ");
+                        }
+                    }
+                    *last_char = chunk->data->buffer[i];
+                    putchar(*last_char);
+                    fflush(stdout);
+                }
+            }
+            render_chunks(chunk->chunks, last_char, indent);
+            chunk = chunk->next;
+        }
+    }
+}
+
+static char symbol_1[] = "x";
+static char symbol_2[] = "x";
+static char symbol_3[] = "xs";
+static char symbol_4[] = "#include <stdio.h>\n";
+static char symbol_5[] = "#include <string.h>\n";
+static char symbol_6[] = "#include <stdlib.h>\n";
+static char symbol_7[] = "#include <stdint.h>\n";
+static char symbol_8[] = "\n";
+static char symbol_9[] = "struct Variables;\n";
+static char symbol_10[] = "\n";
+static char symbol_11[] = "struct Buffer {\n";
+static char symbol_12[] = "char* buffer;\n";
+static char symbol_13[] = "unsigned int size;\n";
+static char symbol_14[] = "};\n";
+static char symbol_15[] = "\n";
+static char symbol_16[] = "struct ParseState {\n";
+static char symbol_17[] = "struct Buffer* input_buffer;\n";
+static char symbol_18[] = "unsigned int pos;\n";
+static char symbol_19[] = "};\n";
+static char symbol_20[] = "\n";
+static char symbol_21[] = "struct Runtime {\n";
+static char symbol_22[] = "struct Chunks* main_chunks;\n";
+static char symbol_23[] = "struct Chunks* current_chunks;\n";
+static char symbol_24[] = "struct Placeholders* placeholders;\n";
+static char symbol_25[] = "};\n";
+static char symbol_26[] = "\n";
+static char symbol_27[] = "struct Action {\n";
+static char symbol_28[] = "void (*function)(struct Runtime*, struct Variables*);\n";
+static char symbol_29[] = "struct Variables* variables;\n";
+static char symbol_30[] = "struct Buffer* input_buffer;\n";
+static char symbol_31[] = "unsigned int start;\n";
+static char symbol_32[] = "unsigned int end;\n";
+static char symbol_33[] = "unsigned int len;\n";
+static char symbol_34[] = "};\n";
+static char symbol_35[] = "\n";
+static char symbol_36[] = "struct Variables {\n";
+static char symbol_37[] = "struct Variable* pre_first;\n";
+static char symbol_38[] = "struct Variable* last;\n";
+static char symbol_39[] = "};\n";
+static char symbol_40[] = "\n";
+static char symbol_41[] = "struct Variable {\n";
+static char symbol_42[] = "struct Variable* next;\n";
+static char symbol_43[] = "struct Buffer* name;\n";
+static char symbol_44[] = "struct Action* action;\n";
+static char symbol_45[] = "};\n";
+static char symbol_46[] = "\n";
+static char symbol_47[] = "struct Chunks {\n";
+static char symbol_48[] = "struct Chunk* pre_first;\n";
+static char symbol_49[] = "struct Chunk* last;\n";
+static char symbol_50[] = "};\n";
+static char symbol_51[] = "\n";
+static char symbol_52[] = "struct Chunk {\n";
+static char symbol_53[] = "struct Chunk* next;\n";
+static char symbol_54[] = "struct Buffer* data;\n";
+static char symbol_55[] = "struct Chunks* chunks;\n";
+static char symbol_56[] = "int indentation_delta;\n";
+static char symbol_57[] = "};\n";
+static char symbol_58[] = "\n";
+static char symbol_59[] = "struct Placeholders {\n";
+static char symbol_60[] = "struct Placeholder* pre_first;\n";
+static char symbol_61[] = "struct Placeholder* last;\n";
+static char symbol_62[] = "};\n";
+static char symbol_63[] = "\n";
+static char symbol_64[] = "struct Placeholder {\n";
+static char symbol_65[] = "struct Placeholder* next;\n";
+static char symbol_66[] = "struct Chunks* chunks;\n";
+static char symbol_67[] = "struct Action* action;\n";
+static char symbol_68[] = "};\n";
+static char symbol_69[] = "\n";
+static char symbol_70[] = "static char* arena;\n";
+static char symbol_71[] = "static unsigned int arena_limit;\n";
+static char symbol_72[] = "static unsigned int arena_pos;\n";
+static char symbol_73[] = "\n";
+static char symbol_74[] = "void* allocate(size_t size) {\n";
+static char symbol_75[] = "void* pointer = arena + arena_pos;\n";
+static char symbol_76[] = "arena_pos += size;\n";
+static char symbol_77[] = "if (arena_pos >= arena_limit) {\n";
+static char symbol_78[] = "fprintf(stderr, \"ERROR: out of memory\");\n";
+static char symbol_79[] = "exit(1);\n";
+static char symbol_80[] = "}\n";
+static char symbol_81[] = "return pointer;\n";
+static char symbol_82[] = "}\n";
+static char symbol_83[] = "\n";
+static char symbol_84[] = "struct ParseState* create_parse_state_from_stdin() {\n";
+static char symbol_85[] = "char* pos;\n";
+static char symbol_86[] = "struct ParseState* parse_state = allocate(sizeof(struct ParseState));\n";
+static char symbol_87[] = "parse_state->input_buffer = allocate(sizeof(struct Buffer));\n";
+static char symbol_88[] = "parse_state->input_buffer->buffer = allocate(1);\n";
+static char symbol_89[] = "parse_state->input_buffer->size = 1;\n";
+static char symbol_90[] = "parse_state->pos = 0;\n";
+static char symbol_91[] = "pos = parse_state->input_buffer->buffer;\n";
+static char symbol_92[] = "while (fgets(pos, 2, stdin)) {\n";
+static char symbol_93[] = "pos = allocate(1);\n";
+static char symbol_94[] = "parse_state->input_buffer->size++;\n";
+static char symbol_95[] = "}\n";
+static char symbol_96[] = "parse_state->input_buffer->size--;\n";
+static char symbol_97[] = "fprintf(stderr, \"debug: stdin data memory = %p\\n\", parse_state->input_buffer->buffer);\n";
+static char symbol_98[] = "return parse_state;\n";
+static char symbol_99[] = "}\n";
+static char symbol_100[] = "\n";
+static char symbol_101[] = "struct Chunks* create_chunks() {\n";
+static char symbol_102[] = "struct Chunks* chunks = allocate(sizeof(struct Chunks));\n";
+static char symbol_103[] = "chunks->pre_first = allocate(sizeof(struct Chunk));\n";
+static char symbol_104[] = "chunks->pre_first->next = NULL;\n";
+static char symbol_105[] = "chunks->last = chunks->pre_first;\n";
+static char symbol_106[] = "return chunks;\n";
+static char symbol_107[] = "}\n";
+static char symbol_108[] = "\n";
+static char symbol_109[] = "struct Placeholders* create_placeholders() {\n";
+static char symbol_110[] = "struct Placeholders* placeholders = allocate(sizeof(struct Placeholders));\n";
+static char symbol_111[] = "placeholders->pre_first = allocate(sizeof(struct Placeholder));\n";
+static char symbol_112[] = "placeholders->pre_first->next = NULL;\n";
+static char symbol_113[] = "placeholders->last = placeholders->pre_first;\n";
+static char symbol_114[] = "return placeholders;\n";
+static char symbol_115[] = "}\n";
+static char symbol_116[] = "\n";
+static char symbol_117[] = "struct Runtime* create_runtime() {\n";
+static char symbol_118[] = "struct Runtime* runtime = allocate(sizeof(struct Runtime));\n";
+static char symbol_119[] = "runtime->main_chunks = create_chunks();\n";
+static char symbol_120[] = "runtime->current_chunks = runtime->main_chunks;\n";
+static char symbol_121[] = "runtime->placeholders = create_placeholders();\n";
+static char symbol_122[] = "return runtime;\n";
+static char symbol_123[] = "}\n";
+static char symbol_124[] = "\n";
+static char symbol_125[] = "struct Action* create_action(void (*function)(struct Runtime*, struct Variables*), struct Variables* variables, struct Buffer* input_buffer, unsigned int start, unsigned int end) {\n";
+static char symbol_126[] = "struct Action* action = allocate(sizeof(struct Action));\n";
+static char symbol_127[] = "action->function = function;\n";
+static char symbol_128[] = "action->variables = variables;\n";
+static char symbol_129[] = "action->input_buffer = input_buffer;\n";
+static char symbol_130[] = "action->start = start;\n";
+static char symbol_131[] = "action->end = end;\n";
+static char symbol_132[] = "action->len = end-start;\n";
+static char symbol_133[] = "fprintf(stderr, \"debug: action [start=%d] [end=%d]\\n\", action->start, action->end);\n";
+static char symbol_134[] = "return action;\n";
+static char symbol_135[] = "}\n";
+static char symbol_136[] = "\n";
+static char symbol_137[] = "struct Variables* create_variables() {\n";
+static char symbol_138[] = "struct Variables* variables = allocate(sizeof(struct Variables));\n";
+static char symbol_139[] = "variables->pre_first = allocate(sizeof(struct Variable));\n";
+static char symbol_140[] = "variables->pre_first->next = NULL;\n";
+static char symbol_141[] = "variables->last = variables->pre_first;\n";
+static char symbol_142[] = "return variables;\n";
+static char symbol_143[] = "}\n";
+static char symbol_144[] = "\n";
+static char symbol_145[] = "void append_data(struct Chunks* chunks, struct Buffer* data, int indentation_delta, struct Chunks* sub_chunks) {\n";
+static char symbol_146[] = "struct Chunk* chunk = allocate(sizeof(struct Chunk));\n";
+static char symbol_147[] = "chunk->next = NULL;\n";
+static char symbol_148[] = "chunk->data = data;\n";
+static char symbol_149[] = "chunk->chunks = sub_chunks;\n";
+static char symbol_150[] = "chunk->indentation_delta = indentation_delta;\n";
+static char symbol_151[] = "chunks->last->next = chunk;\n";
+static char symbol_152[] = "chunks->last = chunk;\n";
+static char symbol_153[] = "fprintf(stderr, \"debug: append chunk = %p\\n\", chunk);\n";
+static char symbol_154[] = "if (chunk->data) {\n";
+static char symbol_155[] = "fprintf(stderr, \"  data = \");\n";
+static char symbol_156[] = "for (int i=0; i<chunk->data->size; i++) {\n";
+static char symbol_157[] = "fprintf(stderr, \"%c\", chunk->data->buffer[i]);\n";
+static char symbol_158[] = "}\n";
+static char symbol_159[] = "fprintf(stderr, \"\\n\");\n";
+static char symbol_160[] = "}\n";
+static char symbol_161[] = "}\n";
+static char symbol_162[] = "\n";
+static char symbol_163[] = "struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {\n";
+static char symbol_164[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
+static char symbol_165[] = "buffer->buffer = data->buffer;\n";
+static char symbol_166[] = "buffer->size = end-start;\n";
+static char symbol_167[] = "buffer->buffer += start;\n";
+static char symbol_168[] = "return buffer;\n";
+static char symbol_169[] = "}\n";
+static char symbol_170[] = "\n";
+static char symbol_171[] = "struct Buffer* buffer_from_cstring(char* data, unsigned int size) {\n";
+static char symbol_172[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
+static char symbol_173[] = "buffer->buffer = data;\n";
+static char symbol_174[] = "buffer->size = size;\n";
+static char symbol_175[] = "return buffer;\n";
+static char symbol_176[] = "}\n";
+static char symbol_177[] = "\n";
+static char symbol_178[] = "struct Buffer* buffer_from_integer(unsigned int value) {\n";
+static char symbol_179[] = "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n";
+static char symbol_180[] = "buffer->buffer = allocate(20);\n";
+static char symbol_181[] = "sprintf(buffer->buffer, \"%d\", value);\n";
+static char symbol_182[] = "buffer->size = strlen(buffer->buffer);\n";
+static char symbol_183[] = "return buffer;\n";
+static char symbol_184[] = "}\n";
+static char symbol_185[] = "\n";
+static char symbol_186[] = "void run_action(struct Action* action, struct Runtime* runtime) {\n";
+static char symbol_187[] = "if (action->function) {\n";
+static char symbol_188[] = "action->function(runtime, action->variables);\n";
+static char symbol_189[] = "} else {\n";
+static char symbol_190[] = "if (action->variables) {\n";
+static char symbol_191[] = "fprintf(stderr, \"debug_run_action variables\\n\");\n";
+static char symbol_192[] = "struct Variable* variable = action->variables->pre_first->next;\n";
+static char symbol_193[] = "while (variable) {\n";
+static char symbol_194[] = "run_action(variable->action, runtime);\n";
+static char symbol_195[] = "variable = variable->next;\n";
+static char symbol_196[] = "}\n";
+static char symbol_197[] = "} else {\n";
+static char symbol_198[] = "fprintf(stderr, \"debug_run_action else\\n\");\n";
+static char symbol_199[] = "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n";
+static char symbol_200[] = "}\n";
+static char symbol_201[] = "}\n";
+static char symbol_202[] = "}\n";
+static char symbol_203[] = "\n";
+static char symbol_204[] = "int compare_buffers(struct Buffer* b1, struct Buffer* b2) {\n";
+static char symbol_205[] = "if (b1->size != b2->size) {\n";
+static char symbol_206[] = "return 0;\n";
+static char symbol_207[] = "}\n";
+static char symbol_208[] = "for (int i=0; i<b1->size; i++) {\n";
+static char symbol_209[] = "if (b1->buffer[i] != b2->buffer[i]) {\n";
+static char symbol_210[] = "return 0;\n";
+static char symbol_211[] = "}\n";
+static char symbol_212[] = "}\n";
+static char symbol_213[] = "return 1;";
+static char symbol_214[] = "}\n";
+static char symbol_215[] = "\n";
+static char symbol_216[] = "int seen(struct Chunks* chunks, struct Buffer* data) {\n";
+static char symbol_217[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
+static char symbol_218[] = "while (chunk) {\n";
+static char symbol_219[] = "if (compare_buffers(chunk->data, data)) {\n";
+static char symbol_220[] = "return 1;\n";
+static char symbol_221[] = "}\n";
+static char symbol_222[] = "chunk = chunk->next;\n";
+static char symbol_223[] = "}\n";
+static char symbol_224[] = "return 0;\n";
+static char symbol_225[] = "}\n";
+static char symbol_226[] = "\n";
+static char symbol_227[] = "void append_named_action(struct Variables* variables, struct Buffer* name, struct Action* action) {\n";
+static char symbol_228[] = "struct Variable* next_variable = allocate(sizeof(struct Variable));\n";
+static char symbol_229[] = "next_variable->next = NULL;\n";
+static char symbol_230[] = "next_variable->name = name;\n";
+static char symbol_231[] = "next_variable->action = action;\n";
+static char symbol_232[] = "variables->last->next = next_variable;\n";
+static char symbol_233[] = "variables->last = next_variable;\n";
+static char symbol_234[] = "}\n";
+static char symbol_235[] = "\n";
+static char symbol_236[] = "struct Action* lookup_action(struct Variables* variables, struct Buffer* name_to_look_for) {\n";
+static char symbol_237[] = "struct Variable* variable = variables->pre_first->next;\n";
+static char symbol_238[] = "while (variable) {\n";
+static char symbol_239[] = "if (compare_buffers(variable->name, name_to_look_for)) {\n";
+static char symbol_240[] = "fprintf(stderr, \"debug: found action %p\\n\", variable->action);\n";
+static char symbol_241[] = "return variable->action;\n";
+static char symbol_242[] = "} else {\n";
+static char symbol_243[] = "variable = variable->next;\n";
+static char symbol_244[] = "}\n";
+static char symbol_245[] = "}\n";
+static char symbol_246[] = "fprintf(stderr, \"ERROR: variable not found\");\n";
+static char symbol_247[] = "exit(1);\n";
+static char symbol_248[] = "}\n";
+static char symbol_249[] = "\n";
+static char symbol_250[] = "void append_placeholder(struct Placeholders* placeholders, struct Chunks* chunks, struct Action* action) {\n";
+static char symbol_251[] = "struct Placeholder* next_placeholder = allocate(sizeof(struct Placeholder));\n";
+static char symbol_252[] = "next_placeholder->next = NULL;\n";
+static char symbol_253[] = "next_placeholder->chunks = chunks;\n";
+static char symbol_254[] = "next_placeholder->action = action;\n";
+static char symbol_255[] = "placeholders->last->next = next_placeholder;\n";
+static char symbol_256[] = "placeholders->last = next_placeholder;\n";
+static char symbol_257[] = "}\n";
+static char symbol_258[] = "\n";
+static char symbol_259[] = "unsigned int inc(unsigned int value, unsigned int amount) {\n";
+static char symbol_260[] = "return value + amount;\n";
+static char symbol_261[] = "}\n";
+static char symbol_262[] = "\n";
+static char symbol_263[] = "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n";
+static char symbol_264[] = "fprintf(stderr, \"debug: render chunks\\n\");\n";
+static char symbol_265[] = "if (chunks) {\n";
+static char symbol_266[] = "struct Chunk* chunk = chunks->pre_first->next;\n";
+static char symbol_267[] = "while (chunk) {\n";
+static char symbol_268[] = "*indent += chunk->indentation_delta;\n";
+static char symbol_269[] = "if (chunk->data) {\n";
+static char symbol_270[] = "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n";
+static char symbol_271[] = "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n";
+static char symbol_272[] = "for (int i=0; i<chunk->data->size; i++) {\n";
+static char symbol_273[] = "if (*last_char == '\\n') {\n";
+static char symbol_274[] = "for (int j=0; j<*indent; j++) {\n";
+static char symbol_275[] = "printf(\"    \");\n";
+static char symbol_276[] = "}\n";
+static char symbol_277[] = "}\n";
+static char symbol_278[] = "*last_char = chunk->data->buffer[i];\n";
+static char symbol_279[] = "putchar(*last_char);\n";
+static char symbol_280[] = "fflush(stdout);\n";
+static char symbol_281[] = "}\n";
+static char symbol_282[] = "}\n";
+static char symbol_283[] = "render_chunks(chunk->chunks, last_char, indent);\n";
+static char symbol_284[] = "chunk = chunk->next;\n";
+static char symbol_285[] = "}\n";
+static char symbol_286[] = "}\n";
+static char symbol_287[] = "}\n";
+static char symbol_288[] = "\n";
+static char symbol_289[] = "\n";
+static char symbol_290[] = "xs";
+static char symbol_291[] = "int main(void) {\n";
+static char symbol_292[] = "arena_limit = 2<<30;\n";
+static char symbol_293[] = "arena_pos = 0;\n";
+static char symbol_294[] = "arena = malloc(arena_limit);\n";
+static char symbol_295[] = "struct ParseState* parse_state = create_parse_state_from_stdin();\n";
+static char symbol_296[] = "char last_char = '\\n';\n";
+static char symbol_297[] = "int indent = 0;\n";
+static char symbol_298[] = "fprintf(stderr, parse_state->input_buffer->buffer);\n";
+static char symbol_299[] = "struct Runtime* runtime = create_runtime();\n";
+static char symbol_300[] = "struct Action* action = rule_main(parse_state);\n";
+static char symbol_301[] = "struct Placeholder* placeholder;\n";
+static char symbol_302[] = "if (action == NULL) {\n";
+static char symbol_303[] = "fprintf(stderr, \"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n";
+static char symbol_304[] = "exit(1);\n";
+static char symbol_305[] = "}\n";
+static char symbol_306[] = "run_action(action, runtime);\n";
+static char symbol_307[] = "placeholder = runtime->placeholders->pre_first->next;\n";
+static char symbol_308[] = "while (placeholder) {\n";
+static char symbol_309[] = "runtime->current_chunks = placeholder->chunks;\n";
+static char symbol_310[] = "run_action(placeholder->action, runtime);\n";
+static char symbol_311[] = "placeholder = placeholder->next;\n";
+static char symbol_312[] = "}\n";
+static char symbol_313[] = "fprintf(stderr, \"debug: arena memory = %p\\n\", arena);\n";
+static char symbol_314[] = "fprintf(stderr, \"debug: arena limit  = %u\\n\", arena_limit);\n";
+static char symbol_315[] = "fprintf(stderr, \"debug: arena used   = %u\\n\", arena_pos);\n";
+static char symbol_316[] = "render_chunks(runtime->main_chunks, &last_char, &indent);\n";
+static char symbol_317[] = "}\n";
+static char symbol_318[] = "x";
+static char symbol_319[] = "=";
+static char symbol_320[] = "y";
+static char symbol_321[] = ";";
+static char symbol_322[] = "struct Action* rule_";
+static char symbol_323[] = "x";
+static char symbol_324[] = "(struct ParseState* parse_state);\n";
+static char symbol_325[] = "struct Action* rule_";
+static char symbol_326[] = "x";
+static char symbol_327[] = "(struct ParseState* parse_state) {\n";
+static char symbol_328[] = "unsigned int or_backtrack_pos;\n";
+static char symbol_329[] = "unsigned int action_start_pos;\n";
+static char symbol_330[] = "unsigned int star_start_pos;\n";
+static char symbol_331[] = "unsigned int star_pos;\n";
+static char symbol_332[] = "unsigned int nlookahead_pos;\n";
+static char symbol_333[] = "struct Variables* variables;\n";
+static char symbol_334[] = "struct Variables* star_variables;\n";
+static char symbol_335[] = "struct Action* _;\n";
+static char symbol_336[] = "struct Buffer* data;\n";
+static char symbol_337[] = "fprintf(stderr, \"debug: rule ";
+static char symbol_338[] = "x";
+static char symbol_339[] = " [pos=%d]\\n\", parse_state->pos);\n";
+static char symbol_340[] = "y";
+static char symbol_341[] = "fprintf(stderr, \"debug: rule fail ";
+static char symbol_342[] = "x";
+static char symbol_343[] = " [pos=%d]\\n\", parse_state->pos);\n";
+static char symbol_344[] = "return NULL;\n";
+static char symbol_345[] = "}\n";
+static char symbol_346[] = "\n";
+static char symbol_347[] = "x";
+static char symbol_348[] = "xs";
+static char symbol_349[] = "or_backtrack_pos = parse_state->pos;\n";
+static char symbol_350[] = "x";
+static char symbol_351[] = "xs";
+static char symbol_352[] = "x";
+static char symbol_353[] = "x";
+static char symbol_354[] = "|";
+static char symbol_355[] = "x";
+static char symbol_356[] = "parse_state->pos = or_backtrack_pos;\n";
+static char symbol_357[] = "action_start_pos = parse_state->pos;\n";
+static char symbol_358[] = "variables = create_variables();\n";
+static char symbol_359[] = "x";
+static char symbol_360[] = "x";
+static char symbol_361[] = "y";
+static char symbol_362[] = "x";
+static char symbol_363[] = "if (_) {\n";
+static char symbol_364[] = "y";
+static char symbol_365[] = "}\n";
+static char symbol_366[] = "y";
+static char symbol_367[] = "y";
+static char symbol_368[] = "!";
+static char symbol_369[] = "x";
+static char symbol_370[] = "nlookahead_pos = parse_state->pos;\n";
+static char symbol_371[] = "x";
+static char symbol_372[] = "if (_ == NULL) {\n";
+static char symbol_373[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);\n";
+static char symbol_374[] = "} else {\n";
+static char symbol_375[] = "_ = NULL;\n";
+static char symbol_376[] = "}\n";
+static char symbol_377[] = "parse_state->pos = nlookahead_pos;\n";
+static char symbol_378[] = "x";
+static char symbol_379[] = "y";
+static char symbol_380[] = "x";
+static char symbol_381[] = "y";
+static char symbol_382[] = ":";
+static char symbol_383[] = "x";
+static char symbol_384[] = "append_named_action(variables, ";
+static char symbol_385[] = "x";
+static char symbol_386[] = ", _);\n";
+static char symbol_387[] = "x";
+static char symbol_388[] = "*";
+static char symbol_389[] = "star_variables = create_variables();\n";
+static char symbol_390[] = "star_start_pos = parse_state->pos;\n";
+static char symbol_391[] = "while (1) {\n";
+static char symbol_392[] = "star_pos = parse_state->pos;\n";
+static char symbol_393[] = "x";
+static char symbol_394[] = "if (_ == NULL) {\n";
+static char symbol_395[] = "parse_state->pos = star_pos;\n";
+static char symbol_396[] = "break;\n";
+static char symbol_397[] = "}\n";
+static char symbol_398[] = "append_named_action(star_variables, NULL, _);\n";
+static char symbol_399[] = "}\n";
+static char symbol_400[] = "fprintf(stderr, \"debug: creating_star [%d, %d, %p]\\n\", star_start_pos, parse_state->pos, star_variables->pre_first->next);\n";
+static char symbol_401[] = "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n";
+static char symbol_402[] = "x";
+static char symbol_403[] = "x";
+static char symbol_404[] = "x";
+static char symbol_405[] = "_ = rule_";
+static char symbol_406[] = "x";
+static char symbol_407[] = "(parse_state);\n";
+static char symbol_408[] = ".";
+static char symbol_409[] = "if (parse_state->pos < parse_state->input_buffer->size) {\n";
+static char symbol_410[] = "parse_state->pos += 1;\n";
+static char symbol_411[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);\n";
+static char symbol_412[] = "} else {\n";
+static char symbol_413[] = "_ = NULL;\n";
+static char symbol_414[] = "}\n";
+static char symbol_415[] = "x";
+static char symbol_416[] = "data = ";
+static char symbol_417[] = "x";
+static char symbol_418[] = ";\n";
+static char symbol_419[] = "if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {\n";
+static char symbol_420[] = "parse_state->pos += data->size;\n";
+static char symbol_421[] = "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);\n";
+static char symbol_422[] = "} else {\n";
+static char symbol_423[] = "_ = NULL;\n";
+static char symbol_424[] = "}\n";
+static char symbol_425[] = "->";
+static char symbol_426[] = "{";
+static char symbol_427[] = "xs";
+static char symbol_428[] = "}";
+static char symbol_429[] = "void action_";
+static char symbol_430[] = "(struct Runtime* runtime, struct Variables* variables) {\n";
+static char symbol_431[] = "struct Chunks* chunks;\n";
+static char symbol_432[] = "struct Chunks* last_chunks;\n";
+static char symbol_433[] = "struct Action* action;\n";
+static char symbol_434[] = "fprintf(stderr, \"debug: running action_";
+static char symbol_435[] = "\\n\");\n";
+static char symbol_436[] = "xs";
+static char symbol_437[] = "}\n";
+static char symbol_438[] = "\n";
+static char symbol_439[] = "return create_action(action_";
+static char symbol_440[] = ", variables, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
+static char symbol_441[] = "return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);\n";
+static char symbol_442[] = "unseen(";
+static char symbol_443[] = "x";
+static char symbol_444[] = ") -> {";
+static char symbol_445[] = "ys";
+static char symbol_446[] = "}";
+static char symbol_447[] = "action = lookup_action(variables, ";
+static char symbol_448[] = "x";
+static char symbol_449[] = ");\n";
+static char symbol_450[] = "if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {\n";
+static char symbol_451[] = "ys";
+static char symbol_452[] = "}\n";
+static char symbol_453[] = ">";
+static char symbol_454[] = "x";
+static char symbol_455[] = "{";
+static char symbol_456[] = "ys";
+static char symbol_457[] = "}";
+static char symbol_458[] = "last_chunks = runtime->current_chunks;\n";
+static char symbol_459[] = "chunks = runtime->named_chunks_";
+static char symbol_460[] = "x";
+static char symbol_461[] = ";\n";
+static char symbol_462[] = "runtime->current_chunks = chunks;\n";
+static char symbol_463[] = "ys";
+static char symbol_464[] = "runtime->current_chunks = last_chunks;\n";
+static char symbol_465[] = "<";
+static char symbol_466[] = "x";
+static char symbol_467[] = "chunks = create_chunks();\n";
+static char symbol_468[] = "runtime->named_chunks_";
+static char symbol_469[] = "x";
+static char symbol_470[] = " = chunks;\n";
+static char symbol_471[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
+static char symbol_472[] = "x";
+static char symbol_473[] = "append_data(runtime->current_chunks, buffer_from_integer(";
+static char symbol_474[] = "x";
+static char symbol_475[] = "), 0, NULL);\n";
+static char symbol_476[] = "x";
+static char symbol_477[] = "run_action(lookup_action(variables, ";
+static char symbol_478[] = "x";
+static char symbol_479[] = "), runtime);\n";
+static char symbol_480[] = "x";
+static char symbol_481[] = "void placeholder_";
+static char symbol_482[] = "(struct Runtime* runtime, struct Variables* variables) {";
+static char symbol_483[] = "x";
+static char symbol_484[] = "}\n";
+static char symbol_485[] = "\n";
+static char symbol_486[] = "chunks = create_chunks()\n";
+static char symbol_487[] = "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_";
+static char symbol_488[] = ", variables, '', 0, 0))\n";
+static char symbol_489[] = "append_data(runtime->current_chunks, NULL, 0, chunks);\n";
+static char symbol_490[] = "x";
+static char symbol_491[] = "append_data(runtime->current_chunks, ";
+static char symbol_492[] = "x";
+static char symbol_493[] = ", 0, NULL);\n";
+static char symbol_494[] = "#";
+static char symbol_495[] = "x";
+static char symbol_496[] = "(";
+static char symbol_497[] = "y";
+static char symbol_498[] = " ";
+static char symbol_499[] = "z";
+static char symbol_500[] = ")";
+static char symbol_501[] = "runtime->W_";
+static char symbol_502[] = "y";
+static char symbol_503[] = " = ";
+static char symbol_504[] = "x";
+static char symbol_505[] = "(runtime->W_";
+static char symbol_506[] = "y";
+static char symbol_507[] = " ? runtime->W_";
+static char symbol_508[] = "y";
+static char symbol_509[] = " : 0, ";
+static char symbol_510[] = "z";
+static char symbol_511[] = ");\n";
+static char symbol_512[] = ">";
+static char symbol_513[] = "xs";
+static char symbol_514[] = "<";
+static char symbol_515[] = "append_data(runtime->current_chunks, NULL, 1, NULL);\n";
+static char symbol_516[] = "xs";
+static char symbol_517[] = "append_data(runtime->current_chunks, NULL, -1, NULL);\n";
+static char symbol_518[] = "x";
+static char symbol_519[] = "x";
+static char symbol_520[] = "struct Chunks* named_chunks_";
+static char symbol_521[] = "x";
+static char symbol_522[] = ";\n";
+static char symbol_523[] = "x";
+static char symbol_524[] = "x";
+static char symbol_525[] = "x";
+static char symbol_526[] = "0";
+static char symbol_527[] = "1";
+static char symbol_528[] = "2";
+static char symbol_529[] = "3";
+static char symbol_530[] = "4";
+static char symbol_531[] = "5";
+static char symbol_532[] = "6";
+static char symbol_533[] = "7";
+static char symbol_534[] = "8";
+static char symbol_535[] = "9";
+static char symbol_536[] = "{";
+static char symbol_537[] = "x";
+static char symbol_538[] = "*";
+static char symbol_539[] = "y";
+static char symbol_540[] = "}";
+static char symbol_541[] = "append_data(runtime->current_chunks, ";
+static char symbol_542[] = "x";
+static char symbol_543[] = "*";
+static char symbol_544[] = "y";
+static char symbol_545[] = ", 0, NULL);\n";
+static char symbol_546[] = "x";
+static char symbol_547[] = "(runtime->W_";
+static char symbol_548[] = "x";
+static char symbol_549[] = " ? runtime->W_";
+static char symbol_550[] = "x";
+static char symbol_551[] = " : 0)";
+static char symbol_552[] = "(";
+static char symbol_553[] = "x";
+static char symbol_554[] = "-";
+static char symbol_555[] = "y";
+static char symbol_556[] = ")";
+static char symbol_557[] = "((runtime->W_";
+static char symbol_558[] = "x";
+static char symbol_559[] = " ? runtime->W_";
+static char symbol_560[] = "x";
+static char symbol_561[] = " : 0)-";
+static char symbol_562[] = "y";
+static char symbol_563[] = ")";
+static char symbol_564[] = "\"";
+static char symbol_565[] = "xs";
+static char symbol_566[] = "\"";
+static char symbol_567[] = "static char symbol_";
+static char symbol_568[] = "[] = \"";
+static char symbol_569[] = "xs";
+static char symbol_570[] = "\";\n";
+static char symbol_571[] = "buffer_from_cstring(symbol_";
+static char symbol_572[] = ", sizeof(symbol_";
+static char symbol_573[] = ")-1)";
+static char symbol_574[] = "x";
+static char symbol_575[] = "xs";
+static char symbol_576[] = "lookup_action(variables, ";
+static char symbol_577[] = "x";
+static char symbol_578[] = ")";
+static char symbol_579[] = "xs";
+static char symbol_580[] = ".";
+static char symbol_581[] = "W[";
+static char symbol_582[] = "x";
+static char symbol_583[] = "]";
+static char symbol_584[] = "x";
+static char symbol_585[] = "unsigned int W_";
+static char symbol_586[] = "x";
+static char symbol_587[] = ";\n";
+static char symbol_588[] = "x";
+static char symbol_589[] = "\\\"";
+static char symbol_590[] = "\"";
+static char symbol_591[] = "xs";
+static char symbol_592[] = "static char symbol_";
+static char symbol_593[] = "[] = \"";
+static char symbol_594[] = "xs";
+static char symbol_595[] = "\";\n";
+static char symbol_596[] = "buffer_from_cstring(symbol_";
+static char symbol_597[] = ", sizeof(symbol_";
+static char symbol_598[] = ")-1)";
+static char symbol_599[] = "\'";
+static char symbol_600[] = "\\\'";
+static char symbol_601[] = "\"";
+static char symbol_602[] = "\\\"";
+static char symbol_603[] = "x";
+static char symbol_604[] = "static char symbol_";
+static char symbol_605[] = "[] = \"";
+static char symbol_606[] = "x";
+static char symbol_607[] = "\";\n";
+static char symbol_608[] = "buffer_from_cstring(symbol_";
+static char symbol_609[] = ", sizeof(symbol_";
+static char symbol_610[] = ")-1)";
+static char symbol_611[] = "a";
+static char symbol_612[] = "b";
+static char symbol_613[] = "c";
+static char symbol_614[] = "d";
+static char symbol_615[] = "e";
+static char symbol_616[] = "f";
+static char symbol_617[] = "g";
+static char symbol_618[] = "h";
+static char symbol_619[] = "i";
+static char symbol_620[] = "j";
+static char symbol_621[] = "k";
+static char symbol_622[] = "l";
+static char symbol_623[] = "m";
+static char symbol_624[] = "n";
+static char symbol_625[] = "o";
+static char symbol_626[] = "p";
+static char symbol_627[] = "q";
+static char symbol_628[] = "r";
+static char symbol_629[] = "s";
+static char symbol_630[] = "t";
+static char symbol_631[] = "u";
+static char symbol_632[] = "v";
+static char symbol_633[] = "w";
+static char symbol_634[] = "x";
+static char symbol_635[] = "y";
+static char symbol_636[] = "z";
+static char symbol_637[] = "A";
+static char symbol_638[] = "B";
+static char symbol_639[] = "C";
+static char symbol_640[] = "D";
+static char symbol_641[] = "E";
+static char symbol_642[] = "F";
+static char symbol_643[] = "G";
+static char symbol_644[] = "H";
+static char symbol_645[] = "I";
+static char symbol_646[] = "J";
+static char symbol_647[] = "K";
+static char symbol_648[] = "L";
+static char symbol_649[] = "M";
+static char symbol_650[] = "N";
+static char symbol_651[] = "O";
+static char symbol_652[] = "P";
+static char symbol_653[] = "Q";
+static char symbol_654[] = "R";
+static char symbol_655[] = "S";
+static char symbol_656[] = "T";
+static char symbol_657[] = "U";
+static char symbol_658[] = "V";
+static char symbol_659[] = "W";
+static char symbol_660[] = "X";
+static char symbol_661[] = "Y";
+static char symbol_662[] = "Z";
+static char symbol_663[] = " ";
+static char symbol_664[] = "\n";
+struct Action* rule_main(struct ParseState* parse_state);
+struct Action* rule_file(struct ParseState* parse_state);
+struct Action* rule_rule(struct ParseState* parse_state);
+struct Action* rule_ors(struct ParseState* parse_state);
+struct Action* rule_restorcase(struct ParseState* parse_state);
+struct Action* rule_maybeorbar(struct ParseState* parse_state);
+struct Action* rule_orbar(struct ParseState* parse_state);
+struct Action* rule_orcase(struct ParseState* parse_state);
+struct Action* rule_matchAnd(struct ParseState* parse_state);
+struct Action* rule_matchExpr(struct ParseState* parse_state);
+struct Action* rule_matchAssign(struct ParseState* parse_state);
+struct Action* rule_matchExprRepeat(struct ParseState* parse_state);
+struct Action* rule_matchExprPrimitive(struct ParseState* parse_state);
+struct Action* rule_action(struct ParseState* parse_state);
+struct Action* rule_actionexpr(struct ParseState* parse_state);
+struct Action* rule_chunkName(struct ParseState* parse_state);
+struct Action* rule_actionPrimitiveExpression(struct ParseState* parse_state);
+struct Action* rule_digit(struct ParseState* parse_state);
+struct Action* rule_placeholder(struct ParseState* parse_state);
+struct Action* rule_expr(struct ParseState* parse_state);
+struct Action* rule_string(struct ParseState* parse_state);
+struct Action* rule_dotname(struct ParseState* parse_state);
+struct Action* rule_nextname(struct ParseState* parse_state);
+struct Action* rule_wvar(struct ParseState* parse_state);
+struct Action* rule_stringinner(struct ParseState* parse_state);
+struct Action* rule_stringend(struct ParseState* parse_state);
+struct Action* rule_charstring(struct ParseState* parse_state);
+struct Action* rule_quote(struct ParseState* parse_state);
+struct Action* rule_innercharstring(struct ParseState* parse_state);
+struct Action* rule_nameAsSymbol(struct ParseState* parse_state);
+struct Action* rule_name(struct ParseState* parse_state);
+struct Action* rule_char(struct ParseState* parse_state);
+struct Action* rule_space(struct ParseState* parse_state);
+struct Action* rule_spacechar(struct ParseState* parse_state);
+
+void action_1(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_1\n");
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_2, sizeof(symbol_2)-1)), runtime);
+}
+
+void action_2(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_2\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_4, sizeof(symbol_4)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_5, sizeof(symbol_5)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_6, sizeof(symbol_6)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_7, sizeof(symbol_7)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_8, sizeof(symbol_8)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_9, sizeof(symbol_9)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_10, sizeof(symbol_10)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_11, sizeof(symbol_11)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_12, sizeof(symbol_12)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_13, sizeof(symbol_13)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_14, sizeof(symbol_14)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_15, sizeof(symbol_15)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_16, sizeof(symbol_16)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_17, sizeof(symbol_17)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_18, sizeof(symbol_18)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_19, sizeof(symbol_19)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_20, sizeof(symbol_20)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_21, sizeof(symbol_21)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_22, sizeof(symbol_22)-1), 0, NULL);
+    chunks = create_chunks();
+    runtime->named_chunks_namedChunks = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_23, sizeof(symbol_23)-1), 0, NULL);
+    chunks = create_chunks();
+    runtime->named_chunks_namedWs = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_24, sizeof(symbol_24)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_25, sizeof(symbol_25)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_26, sizeof(symbol_26)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_27, sizeof(symbol_27)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_28, sizeof(symbol_28)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_29, sizeof(symbol_29)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_30, sizeof(symbol_30)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_31, sizeof(symbol_31)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_32, sizeof(symbol_32)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_33, sizeof(symbol_33)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_34, sizeof(symbol_34)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_35, sizeof(symbol_35)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_36, sizeof(symbol_36)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_37, sizeof(symbol_37)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_38, sizeof(symbol_38)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_39, sizeof(symbol_39)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_40, sizeof(symbol_40)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_41, sizeof(symbol_41)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_42, sizeof(symbol_42)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_43, sizeof(symbol_43)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_44, sizeof(symbol_44)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_45, sizeof(symbol_45)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_46, sizeof(symbol_46)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_47, sizeof(symbol_47)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_48, sizeof(symbol_48)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_49, sizeof(symbol_49)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_50, sizeof(symbol_50)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_51, sizeof(symbol_51)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_52, sizeof(symbol_52)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_53, sizeof(symbol_53)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_54, sizeof(symbol_54)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_55, sizeof(symbol_55)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_56, sizeof(symbol_56)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_57, sizeof(symbol_57)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_58, sizeof(symbol_58)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_59, sizeof(symbol_59)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_60, sizeof(symbol_60)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_61, sizeof(symbol_61)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_62, sizeof(symbol_62)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_63, sizeof(symbol_63)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_64, sizeof(symbol_64)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_65, sizeof(symbol_65)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_66, sizeof(symbol_66)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_67, sizeof(symbol_67)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_68, sizeof(symbol_68)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_69, sizeof(symbol_69)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_70, sizeof(symbol_70)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_71, sizeof(symbol_71)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_72, sizeof(symbol_72)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_73, sizeof(symbol_73)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_74, sizeof(symbol_74)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_75, sizeof(symbol_75)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_76, sizeof(symbol_76)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_77, sizeof(symbol_77)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_78, sizeof(symbol_78)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_79, sizeof(symbol_79)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_80, sizeof(symbol_80)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_81, sizeof(symbol_81)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_82, sizeof(symbol_82)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_83, sizeof(symbol_83)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_84, sizeof(symbol_84)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_85, sizeof(symbol_85)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_86, sizeof(symbol_86)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_87, sizeof(symbol_87)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_88, sizeof(symbol_88)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_89, sizeof(symbol_89)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_90, sizeof(symbol_90)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_91, sizeof(symbol_91)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_92, sizeof(symbol_92)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_93, sizeof(symbol_93)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_94, sizeof(symbol_94)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_95, sizeof(symbol_95)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_96, sizeof(symbol_96)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_97, sizeof(symbol_97)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_98, sizeof(symbol_98)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_99, sizeof(symbol_99)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_100, sizeof(symbol_100)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_101, sizeof(symbol_101)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_102, sizeof(symbol_102)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_103, sizeof(symbol_103)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_104, sizeof(symbol_104)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_105, sizeof(symbol_105)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_106, sizeof(symbol_106)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_107, sizeof(symbol_107)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_108, sizeof(symbol_108)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_109, sizeof(symbol_109)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_110, sizeof(symbol_110)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_111, sizeof(symbol_111)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_112, sizeof(symbol_112)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_113, sizeof(symbol_113)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_114, sizeof(symbol_114)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_115, sizeof(symbol_115)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_116, sizeof(symbol_116)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_117, sizeof(symbol_117)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_118, sizeof(symbol_118)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_119, sizeof(symbol_119)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_120, sizeof(symbol_120)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_121, sizeof(symbol_121)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_122, sizeof(symbol_122)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_123, sizeof(symbol_123)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_124, sizeof(symbol_124)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_125, sizeof(symbol_125)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_126, sizeof(symbol_126)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_127, sizeof(symbol_127)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_128, sizeof(symbol_128)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_129, sizeof(symbol_129)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_130, sizeof(symbol_130)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_131, sizeof(symbol_131)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_132, sizeof(symbol_132)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_133, sizeof(symbol_133)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_134, sizeof(symbol_134)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_135, sizeof(symbol_135)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_136, sizeof(symbol_136)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_137, sizeof(symbol_137)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_138, sizeof(symbol_138)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_139, sizeof(symbol_139)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_140, sizeof(symbol_140)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_141, sizeof(symbol_141)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_142, sizeof(symbol_142)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_143, sizeof(symbol_143)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_144, sizeof(symbol_144)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_145, sizeof(symbol_145)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_146, sizeof(symbol_146)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_147, sizeof(symbol_147)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_148, sizeof(symbol_148)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_149, sizeof(symbol_149)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_150, sizeof(symbol_150)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_151, sizeof(symbol_151)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_152, sizeof(symbol_152)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_153, sizeof(symbol_153)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_154, sizeof(symbol_154)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_155, sizeof(symbol_155)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_156, sizeof(symbol_156)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_157, sizeof(symbol_157)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_158, sizeof(symbol_158)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_159, sizeof(symbol_159)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_160, sizeof(symbol_160)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_161, sizeof(symbol_161)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_162, sizeof(symbol_162)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_163, sizeof(symbol_163)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_164, sizeof(symbol_164)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_165, sizeof(symbol_165)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_166, sizeof(symbol_166)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_167, sizeof(symbol_167)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_168, sizeof(symbol_168)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_169, sizeof(symbol_169)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_170, sizeof(symbol_170)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_171, sizeof(symbol_171)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_172, sizeof(symbol_172)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_173, sizeof(symbol_173)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_174, sizeof(symbol_174)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_175, sizeof(symbol_175)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_176, sizeof(symbol_176)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_177, sizeof(symbol_177)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_178, sizeof(symbol_178)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_179, sizeof(symbol_179)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_180, sizeof(symbol_180)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_181, sizeof(symbol_181)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_182, sizeof(symbol_182)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_183, sizeof(symbol_183)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_184, sizeof(symbol_184)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_185, sizeof(symbol_185)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_186, sizeof(symbol_186)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_187, sizeof(symbol_187)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_188, sizeof(symbol_188)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_189, sizeof(symbol_189)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_190, sizeof(symbol_190)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_191, sizeof(symbol_191)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_192, sizeof(symbol_192)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_193, sizeof(symbol_193)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_194, sizeof(symbol_194)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_195, sizeof(symbol_195)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_196, sizeof(symbol_196)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_197, sizeof(symbol_197)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_198, sizeof(symbol_198)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_199, sizeof(symbol_199)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_200, sizeof(symbol_200)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_201, sizeof(symbol_201)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_202, sizeof(symbol_202)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_203, sizeof(symbol_203)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_204, sizeof(symbol_204)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_205, sizeof(symbol_205)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_206, sizeof(symbol_206)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_207, sizeof(symbol_207)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_208, sizeof(symbol_208)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_209, sizeof(symbol_209)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_210, sizeof(symbol_210)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_211, sizeof(symbol_211)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_212, sizeof(symbol_212)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_213, sizeof(symbol_213)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_214, sizeof(symbol_214)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_215, sizeof(symbol_215)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_216, sizeof(symbol_216)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_217, sizeof(symbol_217)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_218, sizeof(symbol_218)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_219, sizeof(symbol_219)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_220, sizeof(symbol_220)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_221, sizeof(symbol_221)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_222, sizeof(symbol_222)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_223, sizeof(symbol_223)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_224, sizeof(symbol_224)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_225, sizeof(symbol_225)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_226, sizeof(symbol_226)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_227, sizeof(symbol_227)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_228, sizeof(symbol_228)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_229, sizeof(symbol_229)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_230, sizeof(symbol_230)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_231, sizeof(symbol_231)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_232, sizeof(symbol_232)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_233, sizeof(symbol_233)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_234, sizeof(symbol_234)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_235, sizeof(symbol_235)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_236, sizeof(symbol_236)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_237, sizeof(symbol_237)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_238, sizeof(symbol_238)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_239, sizeof(symbol_239)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_240, sizeof(symbol_240)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_241, sizeof(symbol_241)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_242, sizeof(symbol_242)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_243, sizeof(symbol_243)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_244, sizeof(symbol_244)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_245, sizeof(symbol_245)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_246, sizeof(symbol_246)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_247, sizeof(symbol_247)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_248, sizeof(symbol_248)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_249, sizeof(symbol_249)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_250, sizeof(symbol_250)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_251, sizeof(symbol_251)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_252, sizeof(symbol_252)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_253, sizeof(symbol_253)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_254, sizeof(symbol_254)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_255, sizeof(symbol_255)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_256, sizeof(symbol_256)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_257, sizeof(symbol_257)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_258, sizeof(symbol_258)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_259, sizeof(symbol_259)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_260, sizeof(symbol_260)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_261, sizeof(symbol_261)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_262, sizeof(symbol_262)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_263, sizeof(symbol_263)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_264, sizeof(symbol_264)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_265, sizeof(symbol_265)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_266, sizeof(symbol_266)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_267, sizeof(symbol_267)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_268, sizeof(symbol_268)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_269, sizeof(symbol_269)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_270, sizeof(symbol_270)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_271, sizeof(symbol_271)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_272, sizeof(symbol_272)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_273, sizeof(symbol_273)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_274, sizeof(symbol_274)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_275, sizeof(symbol_275)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_276, sizeof(symbol_276)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_277, sizeof(symbol_277)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_278, sizeof(symbol_278)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_279, sizeof(symbol_279)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_280, sizeof(symbol_280)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_281, sizeof(symbol_281)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_282, sizeof(symbol_282)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_283, sizeof(symbol_283)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_284, sizeof(symbol_284)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_285, sizeof(symbol_285)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_286, sizeof(symbol_286)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_287, sizeof(symbol_287)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_288, sizeof(symbol_288)-1), 0, NULL);
+    chunks = create_chunks();
+    runtime->named_chunks_symbols = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    chunks = create_chunks();
+    runtime->named_chunks_definitions = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_289, sizeof(symbol_289)-1), 0, NULL);
+    chunks = create_chunks();
+    runtime->named_chunks_actions = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    chunks = create_chunks();
+    runtime->named_chunks_placeholders = chunks;
+    append_data(runtime->current_chunks, NULL, 0, chunks);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_290, sizeof(symbol_290)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_291, sizeof(symbol_291)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_292, sizeof(symbol_292)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_293, sizeof(symbol_293)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_294, sizeof(symbol_294)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_295, sizeof(symbol_295)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_296, sizeof(symbol_296)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_297, sizeof(symbol_297)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_298, sizeof(symbol_298)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_299, sizeof(symbol_299)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_300, sizeof(symbol_300)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_301, sizeof(symbol_301)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_302, sizeof(symbol_302)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_303, sizeof(symbol_303)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_304, sizeof(symbol_304)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_305, sizeof(symbol_305)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_306, sizeof(symbol_306)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_307, sizeof(symbol_307)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_308, sizeof(symbol_308)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_309, sizeof(symbol_309)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_310, sizeof(symbol_310)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_311, sizeof(symbol_311)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_312, sizeof(symbol_312)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_313, sizeof(symbol_313)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_314, sizeof(symbol_314)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_315, sizeof(symbol_315)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_316, sizeof(symbol_316)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_317, sizeof(symbol_317)-1), 0, NULL);
+}
+
+void action_3(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_3\n");
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_definitions;
+    runtime->current_chunks = chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_322, sizeof(symbol_322)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_323, sizeof(symbol_323)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_324, sizeof(symbol_324)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_325, sizeof(symbol_325)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_326, sizeof(symbol_326)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_327, sizeof(symbol_327)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_328, sizeof(symbol_328)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_329, sizeof(symbol_329)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_330, sizeof(symbol_330)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_331, sizeof(symbol_331)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_332, sizeof(symbol_332)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_333, sizeof(symbol_333)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_334, sizeof(symbol_334)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_335, sizeof(symbol_335)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_336, sizeof(symbol_336)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_337, sizeof(symbol_337)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_338, sizeof(symbol_338)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_339, sizeof(symbol_339)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_340, sizeof(symbol_340)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_341, sizeof(symbol_341)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_342, sizeof(symbol_342)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_343, sizeof(symbol_343)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_344, sizeof(symbol_344)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_345, sizeof(symbol_345)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_346, sizeof(symbol_346)-1), 0, NULL);
+}
+
+void action_4(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_4\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_349, sizeof(symbol_349)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_350, sizeof(symbol_350)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_351, sizeof(symbol_351)-1)), runtime);
+}
+
+void action_5(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_5\n");
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_353, sizeof(symbol_353)-1)), runtime);
+}
+
+void action_6(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_6\n");
+}
+
+void action_7(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_7\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_356, sizeof(symbol_356)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_357, sizeof(symbol_357)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_358, sizeof(symbol_358)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_359, sizeof(symbol_359)-1)), runtime);
+}
+
+void action_8(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_8\n");
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_362, sizeof(symbol_362)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_363, sizeof(symbol_363)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_364, sizeof(symbol_364)-1)), runtime);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_365, sizeof(symbol_365)-1), 0, NULL);
+}
+
+void action_9(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_9\n");
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_367, sizeof(symbol_367)-1)), runtime);
+}
+
+void action_10(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_10\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_370, sizeof(symbol_370)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_371, sizeof(symbol_371)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_372, sizeof(symbol_372)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_373, sizeof(symbol_373)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_374, sizeof(symbol_374)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_375, sizeof(symbol_375)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_376, sizeof(symbol_376)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_377, sizeof(symbol_377)-1), 0, NULL);
+}
+
+void action_11(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_11\n");
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_380, sizeof(symbol_380)-1)), runtime);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_381, sizeof(symbol_381)-1)), runtime);
+}
+
+void action_12(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_12\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_384, sizeof(symbol_384)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_385, sizeof(symbol_385)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_386, sizeof(symbol_386)-1), 0, NULL);
+}
+
+void action_13(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_13\n");
+}
+
+void action_14(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_14\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_389, sizeof(symbol_389)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_390, sizeof(symbol_390)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_391, sizeof(symbol_391)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_392, sizeof(symbol_392)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_393, sizeof(symbol_393)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_394, sizeof(symbol_394)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_395, sizeof(symbol_395)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_396, sizeof(symbol_396)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_397, sizeof(symbol_397)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_398, sizeof(symbol_398)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_399, sizeof(symbol_399)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_400, sizeof(symbol_400)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_401, sizeof(symbol_401)-1), 0, NULL);
+}
+
+void action_15(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_15\n");
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_403, sizeof(symbol_403)-1)), runtime);
+}
+
+void action_16(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_16\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_405, sizeof(symbol_405)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_406, sizeof(symbol_406)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_407, sizeof(symbol_407)-1), 0, NULL);
+}
+
+void action_17(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_17\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_409, sizeof(symbol_409)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_410, sizeof(symbol_410)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_411, sizeof(symbol_411)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_412, sizeof(symbol_412)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_413, sizeof(symbol_413)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_414, sizeof(symbol_414)-1), 0, NULL);
+}
+
+void action_18(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_18\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_416, sizeof(symbol_416)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_417, sizeof(symbol_417)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_418, sizeof(symbol_418)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_419, sizeof(symbol_419)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_420, sizeof(symbol_420)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_421, sizeof(symbol_421)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_422, sizeof(symbol_422)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_423, sizeof(symbol_423)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_424, sizeof(symbol_424)-1), 0, NULL);
+}
+
+void action_19(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_19\n");
+    runtime->W_0 = inc(runtime->W_0 ? runtime->W_0 : 0, 1);
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_actions;
+    runtime->current_chunks = chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_429, sizeof(symbol_429)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_430, sizeof(symbol_430)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_431, sizeof(symbol_431)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_432, sizeof(symbol_432)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_433, sizeof(symbol_433)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_434, sizeof(symbol_434)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_435, sizeof(symbol_435)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_436, sizeof(symbol_436)-1)), runtime);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_437, sizeof(symbol_437)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_438, sizeof(symbol_438)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_439, sizeof(symbol_439)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_0 ? runtime->W_0 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_440, sizeof(symbol_440)-1), 0, NULL);
+}
+
+void action_20(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_20\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_441, sizeof(symbol_441)-1), 0, NULL);
+}
+
+void action_21(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_21\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_447, sizeof(symbol_447)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_448, sizeof(symbol_448)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_449, sizeof(symbol_449)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_450, sizeof(symbol_450)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_451, sizeof(symbol_451)-1)), runtime);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_452, sizeof(symbol_452)-1), 0, NULL);
+}
+
+void action_22(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_22\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_458, sizeof(symbol_458)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_459, sizeof(symbol_459)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_460, sizeof(symbol_460)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_461, sizeof(symbol_461)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_462, sizeof(symbol_462)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_463, sizeof(symbol_463)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_464, sizeof(symbol_464)-1), 0, NULL);
+}
+
+void action_23(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_23\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_467, sizeof(symbol_467)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_468, sizeof(symbol_468)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_469, sizeof(symbol_469)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_470, sizeof(symbol_470)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_471, sizeof(symbol_471)-1), 0, NULL);
+}
+
+void action_24(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_24\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_473, sizeof(symbol_473)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_474, sizeof(symbol_474)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_475, sizeof(symbol_475)-1), 0, NULL);
+}
+
+void action_25(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_25\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_477, sizeof(symbol_477)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_478, sizeof(symbol_478)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_479, sizeof(symbol_479)-1), 0, NULL);
+}
+
+void action_26(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_26\n");
+    runtime->W_1 = inc(runtime->W_1 ? runtime->W_1 : 0, 1);
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_placeholders;
+    runtime->current_chunks = chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_481, sizeof(symbol_481)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_482, sizeof(symbol_482)-1), 0, NULL);
+    append_data(runtime->current_chunks, NULL, 1, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_483, sizeof(symbol_483)-1)), runtime);
+    append_data(runtime->current_chunks, NULL, -1, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_484, sizeof(symbol_484)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_485, sizeof(symbol_485)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_486, sizeof(symbol_486)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_487, sizeof(symbol_487)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_1 ? runtime->W_1 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_488, sizeof(symbol_488)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_489, sizeof(symbol_489)-1), 0, NULL);
+}
+
+void action_27(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_27\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_491, sizeof(symbol_491)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_492, sizeof(symbol_492)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_493, sizeof(symbol_493)-1), 0, NULL);
+}
+
+void action_28(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_28\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_501, sizeof(symbol_501)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_502, sizeof(symbol_502)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_503, sizeof(symbol_503)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_504, sizeof(symbol_504)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_505, sizeof(symbol_505)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_506, sizeof(symbol_506)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_507, sizeof(symbol_507)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_508, sizeof(symbol_508)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_509, sizeof(symbol_509)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_510, sizeof(symbol_510)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_511, sizeof(symbol_511)-1), 0, NULL);
+}
+
+void action_29(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_29\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_515, sizeof(symbol_515)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_516, sizeof(symbol_516)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_517, sizeof(symbol_517)-1), 0, NULL);
+}
+
+void action_30(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_30\n");
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_namedChunks;
+    runtime->current_chunks = chunks;
+    action = lookup_action(variables, buffer_from_cstring(symbol_519, sizeof(symbol_519)-1));
+    if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_520, sizeof(symbol_520)-1), 0, NULL);
+        run_action(lookup_action(variables, buffer_from_cstring(symbol_521, sizeof(symbol_521)-1)), runtime);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_522, sizeof(symbol_522)-1), 0, NULL);
+    }
+    runtime->current_chunks = last_chunks;
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_523, sizeof(symbol_523)-1)), runtime);
+}
+
+void action_31(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_31\n");
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_525, sizeof(symbol_525)-1)), runtime);
+}
+
+void action_32(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_32\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_541, sizeof(symbol_541)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_542, sizeof(symbol_542)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_543, sizeof(symbol_543)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_544, sizeof(symbol_544)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_545, sizeof(symbol_545)-1), 0, NULL);
+}
+
+void action_33(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_33\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_547, sizeof(symbol_547)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_548, sizeof(symbol_548)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_549, sizeof(symbol_549)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_550, sizeof(symbol_550)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_551, sizeof(symbol_551)-1), 0, NULL);
+}
+
+void action_34(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_34\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_557, sizeof(symbol_557)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_558, sizeof(symbol_558)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_559, sizeof(symbol_559)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_560, sizeof(symbol_560)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_561, sizeof(symbol_561)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_562, sizeof(symbol_562)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_563, sizeof(symbol_563)-1), 0, NULL);
+}
+
+void action_35(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_35\n");
+    runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_symbols;
+    runtime->current_chunks = chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_567, sizeof(symbol_567)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_568, sizeof(symbol_568)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_569, sizeof(symbol_569)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_570, sizeof(symbol_570)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_571, sizeof(symbol_571)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_572, sizeof(symbol_572)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_573, sizeof(symbol_573)-1), 0, NULL);
+}
+
+void action_36(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_36\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_576, sizeof(symbol_576)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_577, sizeof(symbol_577)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_578, sizeof(symbol_578)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_579, sizeof(symbol_579)-1)), runtime);
+}
+
+void action_37(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_37\n");
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_namedWs;
+    runtime->current_chunks = chunks;
+    action = lookup_action(variables, buffer_from_cstring(symbol_584, sizeof(symbol_584)-1));
+    if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_585, sizeof(symbol_585)-1), 0, NULL);
+        run_action(lookup_action(variables, buffer_from_cstring(symbol_586, sizeof(symbol_586)-1)), runtime);
+        append_data(runtime->current_chunks, buffer_from_cstring(symbol_587, sizeof(symbol_587)-1), 0, NULL);
+    }
+    runtime->current_chunks = last_chunks;
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_588, sizeof(symbol_588)-1)), runtime);
+}
+
+void action_38(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_38\n");
+    runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_symbols;
+    runtime->current_chunks = chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_592, sizeof(symbol_592)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_593, sizeof(symbol_593)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_594, sizeof(symbol_594)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_595, sizeof(symbol_595)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_596, sizeof(symbol_596)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_597, sizeof(symbol_597)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_598, sizeof(symbol_598)-1), 0, NULL);
+}
+
+void action_39(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_39\n");
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_602, sizeof(symbol_602)-1), 0, NULL);
+}
+
+void action_40(struct Runtime* runtime, struct Variables* variables) {
+    struct Chunks* chunks;
+    struct Chunks* last_chunks;
+    struct Action* action;
+    fprintf(stderr, "debug: running action_40\n");
+    runtime->W_2 = inc(runtime->W_2 ? runtime->W_2 : 0, 1);
+    last_chunks = runtime->current_chunks;
+    chunks = runtime->named_chunks_symbols;
+    runtime->current_chunks = chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_604, sizeof(symbol_604)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_605, sizeof(symbol_605)-1), 0, NULL);
+    run_action(lookup_action(variables, buffer_from_cstring(symbol_606, sizeof(symbol_606)-1)), runtime);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_607, sizeof(symbol_607)-1), 0, NULL);
+    runtime->current_chunks = last_chunks;
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_608, sizeof(symbol_608)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_609, sizeof(symbol_609)-1), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_integer((runtime->W_2 ? runtime->W_2 : 0)), 0, NULL);
+    append_data(runtime->current_chunks, buffer_from_cstring(symbol_610, sizeof(symbol_610)-1), 0, NULL);
+}
+
+struct Action* rule_main(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule main [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_file(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_1, sizeof(symbol_1)-1), _);
+    if (_) {
+        return create_action(action_1, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail main [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_file(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule file [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    star_variables = create_variables();
+    star_start_pos = parse_state->pos;
+    while (1) {
+        star_pos = parse_state->pos;
+        _ = rule_rule(parse_state);
+        if (_ == NULL) {
+            parse_state->pos = star_pos;
+            break;
+        }
+        append_named_action(star_variables, NULL, _);
+    }
+    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+    _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+    append_named_action(variables, buffer_from_cstring(symbol_3, sizeof(symbol_3)-1), _);
+    if (_) {
+        _ = rule_space(parse_state);
+        if (_) {
+            nlookahead_pos = parse_state->pos;
+            if (parse_state->pos < parse_state->input_buffer->size) {
+                parse_state->pos += 1;
+                _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);
+            } else {
+                _ = NULL;
+            }
+            if (_ == NULL) {
+                _ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);
+            } else {
+                _ = NULL;
+            }
+            parse_state->pos = nlookahead_pos;
+            if (_) {
+                return create_action(action_2, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail file [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_rule(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule rule [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        _ = rule_name(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_318, sizeof(symbol_318)-1), _);
+        if (_) {
+            _ = rule_space(parse_state);
+            if (_) {
+                data = buffer_from_cstring(symbol_319, sizeof(symbol_319)-1);
+                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                    parse_state->pos += data->size;
+                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                } else {
+                    _ = NULL;
+                }
+                if (_) {
+                    _ = rule_space(parse_state);
+                    if (_) {
+                        _ = rule_ors(parse_state);
+                        append_named_action(variables, buffer_from_cstring(symbol_320, sizeof(symbol_320)-1), _);
+                        if (_) {
+                            _ = rule_space(parse_state);
+                            if (_) {
+                                data = buffer_from_cstring(symbol_321, sizeof(symbol_321)-1);
+                                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                                    parse_state->pos += data->size;
+                                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                                } else {
+                                    _ = NULL;
+                                }
+                                if (_) {
+                                    return create_action(action_3, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail rule [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_ors(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule ors [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_maybeorbar(parse_state);
+    if (_) {
+        _ = rule_orcase(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_347, sizeof(symbol_347)-1), _);
+        if (_) {
+            star_variables = create_variables();
+            star_start_pos = parse_state->pos;
+            while (1) {
+                star_pos = parse_state->pos;
+                _ = rule_restorcase(parse_state);
+                if (_ == NULL) {
+                    parse_state->pos = star_pos;
+                    break;
+                }
+                append_named_action(star_variables, NULL, _);
+            }
+            fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+            _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+            append_named_action(variables, buffer_from_cstring(symbol_348, sizeof(symbol_348)-1), _);
+            if (_) {
+                return create_action(action_4, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail ors [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_restorcase(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule restorcase [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_orbar(parse_state);
+    if (_) {
+        _ = rule_orcase(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_352, sizeof(symbol_352)-1), _);
+        if (_) {
+            return create_action(action_5, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail restorcase [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_maybeorbar(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule maybeorbar [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_orbar(parse_state);
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    return create_action(action_6, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    fprintf(stderr, "debug: rule fail maybeorbar [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_orbar(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule orbar [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        data = buffer_from_cstring(symbol_354, sizeof(symbol_354)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail orbar [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_orcase(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule orcase [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_matchAnd(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_355, sizeof(symbol_355)-1), _);
+    if (_) {
+        return create_action(action_7, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail orcase [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_matchAnd(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule matchAnd [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        _ = rule_matchExpr(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_360, sizeof(symbol_360)-1), _);
+        if (_) {
+            _ = rule_matchAnd(parse_state);
+            append_named_action(variables, buffer_from_cstring(symbol_361, sizeof(symbol_361)-1), _);
+            if (_) {
+                return create_action(action_8, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            }
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_action(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_366, sizeof(symbol_366)-1), _);
+    if (_) {
+        return create_action(action_9, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail matchAnd [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_matchExpr(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule matchExpr [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_368, sizeof(symbol_368)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        _ = rule_matchExprPrimitive(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_369, sizeof(symbol_369)-1), _);
+        if (_) {
+            return create_action(action_10, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_matchExprRepeat(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_378, sizeof(symbol_378)-1), _);
+    if (_) {
+        _ = rule_matchAssign(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_379, sizeof(symbol_379)-1), _);
+        if (_) {
+            return create_action(action_11, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail matchExpr [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_matchAssign(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule matchAssign [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_382, sizeof(symbol_382)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        _ = rule_nameAsSymbol(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_383, sizeof(symbol_383)-1), _);
+        if (_) {
+            return create_action(action_12, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    return create_action(action_13, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    fprintf(stderr, "debug: rule fail matchAssign [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_matchExprRepeat(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule matchExprRepeat [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_matchExprPrimitive(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_387, sizeof(symbol_387)-1), _);
+    if (_) {
+        data = buffer_from_cstring(symbol_388, sizeof(symbol_388)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            return create_action(action_14, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_matchExprPrimitive(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_402, sizeof(symbol_402)-1), _);
+    if (_) {
+        return create_action(action_15, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail matchExprRepeat [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_matchExprPrimitive(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule matchExprPrimitive [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_name(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_404, sizeof(symbol_404)-1), _);
+    if (_) {
+        return create_action(action_16, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_408, sizeof(symbol_408)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(action_17, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_charstring(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_415, sizeof(symbol_415)-1), _);
+    if (_) {
+        return create_action(action_18, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail matchExprPrimitive [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_action(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule action [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        data = buffer_from_cstring(symbol_425, sizeof(symbol_425)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            _ = rule_space(parse_state);
+            if (_) {
+                data = buffer_from_cstring(symbol_426, sizeof(symbol_426)-1);
+                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                    parse_state->pos += data->size;
+                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                } else {
+                    _ = NULL;
+                }
+                if (_) {
+                    star_variables = create_variables();
+                    star_start_pos = parse_state->pos;
+                    while (1) {
+                        star_pos = parse_state->pos;
+                        _ = rule_actionexpr(parse_state);
+                        if (_ == NULL) {
+                            parse_state->pos = star_pos;
+                            break;
+                        }
+                        append_named_action(star_variables, NULL, _);
+                    }
+                    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+                    _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+                    append_named_action(variables, buffer_from_cstring(symbol_427, sizeof(symbol_427)-1), _);
+                    if (_) {
+                        _ = rule_space(parse_state);
+                        if (_) {
+                            data = buffer_from_cstring(symbol_428, sizeof(symbol_428)-1);
+                            if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                                parse_state->pos += data->size;
+                                _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                            } else {
+                                _ = NULL;
+                            }
+                            if (_) {
+                                return create_action(action_19, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    return create_action(action_20, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    fprintf(stderr, "debug: rule fail action [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_actionexpr(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule actionexpr [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        data = buffer_from_cstring(symbol_442, sizeof(symbol_442)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            _ = rule_nameAsSymbol(parse_state);
+            append_named_action(variables, buffer_from_cstring(symbol_443, sizeof(symbol_443)-1), _);
+            if (_) {
+                data = buffer_from_cstring(symbol_444, sizeof(symbol_444)-1);
+                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                    parse_state->pos += data->size;
+                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                } else {
+                    _ = NULL;
+                }
+                if (_) {
+                    star_variables = create_variables();
+                    star_start_pos = parse_state->pos;
+                    while (1) {
+                        star_pos = parse_state->pos;
+                        _ = rule_actionexpr(parse_state);
+                        if (_ == NULL) {
+                            parse_state->pos = star_pos;
+                            break;
+                        }
+                        append_named_action(star_variables, NULL, _);
+                    }
+                    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+                    _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+                    append_named_action(variables, buffer_from_cstring(symbol_445, sizeof(symbol_445)-1), _);
+                    if (_) {
+                        _ = rule_space(parse_state);
+                        if (_) {
+                            data = buffer_from_cstring(symbol_446, sizeof(symbol_446)-1);
+                            if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                                parse_state->pos += data->size;
+                                _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                            } else {
+                                _ = NULL;
+                            }
+                            if (_) {
+                                return create_action(action_21, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        data = buffer_from_cstring(symbol_453, sizeof(symbol_453)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            _ = rule_chunkName(parse_state);
+            append_named_action(variables, buffer_from_cstring(symbol_454, sizeof(symbol_454)-1), _);
+            if (_) {
+                _ = rule_space(parse_state);
+                if (_) {
+                    data = buffer_from_cstring(symbol_455, sizeof(symbol_455)-1);
+                    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                        parse_state->pos += data->size;
+                        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                    } else {
+                        _ = NULL;
+                    }
+                    if (_) {
+                        star_variables = create_variables();
+                        star_start_pos = parse_state->pos;
+                        while (1) {
+                            star_pos = parse_state->pos;
+                            _ = rule_actionexpr(parse_state);
+                            if (_ == NULL) {
+                                parse_state->pos = star_pos;
+                                break;
+                            }
+                            append_named_action(star_variables, NULL, _);
+                        }
+                        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+                        _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+                        append_named_action(variables, buffer_from_cstring(symbol_456, sizeof(symbol_456)-1), _);
+                        if (_) {
+                            _ = rule_space(parse_state);
+                            if (_) {
+                                data = buffer_from_cstring(symbol_457, sizeof(symbol_457)-1);
+                                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                                    parse_state->pos += data->size;
+                                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                                } else {
+                                    _ = NULL;
+                                }
+                                if (_) {
+                                    return create_action(action_22, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        data = buffer_from_cstring(symbol_465, sizeof(symbol_465)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            _ = rule_chunkName(parse_state);
+            append_named_action(variables, buffer_from_cstring(symbol_466, sizeof(symbol_466)-1), _);
+            if (_) {
+                return create_action(action_23, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            }
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        _ = rule_expr(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_472, sizeof(symbol_472)-1), _);
+        if (_) {
+            return create_action(action_24, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        _ = rule_nameAsSymbol(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_476, sizeof(symbol_476)-1), _);
+        if (_) {
+            return create_action(action_25, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        _ = rule_placeholder(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_480, sizeof(symbol_480)-1), _);
+        if (_) {
+            return create_action(action_26, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        _ = rule_string(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_490, sizeof(symbol_490)-1), _);
+        if (_) {
+            return create_action(action_27, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        data = buffer_from_cstring(symbol_494, sizeof(symbol_494)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            _ = rule_name(parse_state);
+            append_named_action(variables, buffer_from_cstring(symbol_495, sizeof(symbol_495)-1), _);
+            if (_) {
+                data = buffer_from_cstring(symbol_496, sizeof(symbol_496)-1);
+                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                    parse_state->pos += data->size;
+                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                } else {
+                    _ = NULL;
+                }
+                if (_) {
+                    _ = rule_wvar(parse_state);
+                    append_named_action(variables, buffer_from_cstring(symbol_497, sizeof(symbol_497)-1), _);
+                    if (_) {
+                        data = buffer_from_cstring(symbol_498, sizeof(symbol_498)-1);
+                        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                            parse_state->pos += data->size;
+                            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                        } else {
+                            _ = NULL;
+                        }
+                        if (_) {
+                            _ = rule_actionPrimitiveExpression(parse_state);
+                            append_named_action(variables, buffer_from_cstring(symbol_499, sizeof(symbol_499)-1), _);
+                            if (_) {
+                                data = buffer_from_cstring(symbol_500, sizeof(symbol_500)-1);
+                                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                                    parse_state->pos += data->size;
+                                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                                } else {
+                                    _ = NULL;
+                                }
+                                if (_) {
+                                    return create_action(action_28, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_space(parse_state);
+    if (_) {
+        data = buffer_from_cstring(symbol_512, sizeof(symbol_512)-1);
+        if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+            parse_state->pos += data->size;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            star_variables = create_variables();
+            star_start_pos = parse_state->pos;
+            while (1) {
+                star_pos = parse_state->pos;
+                _ = rule_actionexpr(parse_state);
+                if (_ == NULL) {
+                    parse_state->pos = star_pos;
+                    break;
+                }
+                append_named_action(star_variables, NULL, _);
+            }
+            fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+            _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+            append_named_action(variables, buffer_from_cstring(symbol_513, sizeof(symbol_513)-1), _);
+            if (_) {
+                _ = rule_space(parse_state);
+                if (_) {
+                    data = buffer_from_cstring(symbol_514, sizeof(symbol_514)-1);
+                    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                        parse_state->pos += data->size;
+                        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                    } else {
+                        _ = NULL;
+                    }
+                    if (_) {
+                        return create_action(action_29, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                    }
+                }
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail actionexpr [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_chunkName(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule chunkName [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_name(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_518, sizeof(symbol_518)-1), _);
+    if (_) {
+        return create_action(action_30, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail chunkName [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_actionPrimitiveExpression(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule actionPrimitiveExpression [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_dotname(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_524, sizeof(symbol_524)-1), _);
+    if (_) {
+        return create_action(action_31, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_digit(parse_state);
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail actionPrimitiveExpression [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_digit(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule digit [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_526, sizeof(symbol_526)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_527, sizeof(symbol_527)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_528, sizeof(symbol_528)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_529, sizeof(symbol_529)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_530, sizeof(symbol_530)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_531, sizeof(symbol_531)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_532, sizeof(symbol_532)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_533, sizeof(symbol_533)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_534, sizeof(symbol_534)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_535, sizeof(symbol_535)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail digit [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_placeholder(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule placeholder [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_536, sizeof(symbol_536)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        _ = rule_space(parse_state);
+        if (_) {
+            _ = rule_string(parse_state);
+            append_named_action(variables, buffer_from_cstring(symbol_537, sizeof(symbol_537)-1), _);
+            if (_) {
+                data = buffer_from_cstring(symbol_538, sizeof(symbol_538)-1);
+                if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                    parse_state->pos += data->size;
+                    _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                } else {
+                    _ = NULL;
+                }
+                if (_) {
+                    _ = rule_expr(parse_state);
+                    append_named_action(variables, buffer_from_cstring(symbol_539, sizeof(symbol_539)-1), _);
+                    if (_) {
+                        _ = rule_space(parse_state);
+                        if (_) {
+                            data = buffer_from_cstring(symbol_540, sizeof(symbol_540)-1);
+                            if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                                parse_state->pos += data->size;
+                                _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                            } else {
+                                _ = NULL;
+                            }
+                            if (_) {
+                                return create_action(action_32, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail placeholder [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_expr(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule expr [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_wvar(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_546, sizeof(symbol_546)-1), _);
+    if (_) {
+        return create_action(action_33, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_552, sizeof(symbol_552)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        _ = rule_wvar(parse_state);
+        append_named_action(variables, buffer_from_cstring(symbol_553, sizeof(symbol_553)-1), _);
+        if (_) {
+            data = buffer_from_cstring(symbol_554, sizeof(symbol_554)-1);
+            if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                parse_state->pos += data->size;
+                _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+            } else {
+                _ = NULL;
+            }
+            if (_) {
+                _ = rule_dotname(parse_state);
+                append_named_action(variables, buffer_from_cstring(symbol_555, sizeof(symbol_555)-1), _);
+                if (_) {
+                    data = buffer_from_cstring(symbol_556, sizeof(symbol_556)-1);
+                    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                        parse_state->pos += data->size;
+                        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+                    } else {
+                        _ = NULL;
+                    }
+                    if (_) {
+                        return create_action(action_34, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+                    }
+                }
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail expr [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_string(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule string [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_564, sizeof(symbol_564)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        star_variables = create_variables();
+        star_start_pos = parse_state->pos;
+        while (1) {
+            star_pos = parse_state->pos;
+            _ = rule_stringinner(parse_state);
+            if (_ == NULL) {
+                parse_state->pos = star_pos;
+                break;
+            }
+            append_named_action(star_variables, NULL, _);
+        }
+        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+        _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+        append_named_action(variables, buffer_from_cstring(symbol_565, sizeof(symbol_565)-1), _);
+        if (_) {
+            data = buffer_from_cstring(symbol_566, sizeof(symbol_566)-1);
+            if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                parse_state->pos += data->size;
+                _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+            } else {
+                _ = NULL;
+            }
+            if (_) {
+                return create_action(action_35, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail string [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_dotname(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule dotname [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_nameAsSymbol(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_574, sizeof(symbol_574)-1), _);
+    if (_) {
+        star_variables = create_variables();
+        star_start_pos = parse_state->pos;
+        while (1) {
+            star_pos = parse_state->pos;
+            _ = rule_nextname(parse_state);
+            if (_ == NULL) {
+                parse_state->pos = star_pos;
+                break;
+            }
+            append_named_action(star_variables, NULL, _);
+        }
+        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+        _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+        append_named_action(variables, buffer_from_cstring(symbol_575, sizeof(symbol_575)-1), _);
+        if (_) {
+            return create_action(action_36, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail dotname [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_nextname(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule nextname [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_580, sizeof(symbol_580)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        _ = rule_name(parse_state);
+        if (_) {
+            return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail nextname [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_wvar(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule wvar [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_581, sizeof(symbol_581)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        if (parse_state->pos < parse_state->input_buffer->size) {
+            parse_state->pos += 1;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        append_named_action(variables, buffer_from_cstring(symbol_582, sizeof(symbol_582)-1), _);
+        if (_) {
+            data = buffer_from_cstring(symbol_583, sizeof(symbol_583)-1);
+            if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+                parse_state->pos += data->size;
+                _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+            } else {
+                _ = NULL;
+            }
+            if (_) {
+                return create_action(action_37, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail wvar [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_stringinner(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule stringinner [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_589, sizeof(symbol_589)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    nlookahead_pos = parse_state->pos;
+    _ = rule_stringend(parse_state);
+    if (_ == NULL) {
+        _ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);
+    } else {
+        _ = NULL;
+    }
+    parse_state->pos = nlookahead_pos;
+    if (_) {
+        if (parse_state->pos < parse_state->input_buffer->size) {
+            parse_state->pos += 1;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail stringinner [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_stringend(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule stringend [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_590, sizeof(symbol_590)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail stringend [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_charstring(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule charstring [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_quote(parse_state);
+    if (_) {
+        star_variables = create_variables();
+        star_start_pos = parse_state->pos;
+        while (1) {
+            star_pos = parse_state->pos;
+            _ = rule_innercharstring(parse_state);
+            if (_ == NULL) {
+                parse_state->pos = star_pos;
+                break;
+            }
+            append_named_action(star_variables, NULL, _);
+        }
+        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+        _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+        append_named_action(variables, buffer_from_cstring(symbol_591, sizeof(symbol_591)-1), _);
+        if (_) {
+            _ = rule_quote(parse_state);
+            if (_) {
+                return create_action(action_38, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+            }
+        }
+    }
+    fprintf(stderr, "debug: rule fail charstring [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_quote(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule quote [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_599, sizeof(symbol_599)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail quote [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_innercharstring(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule innercharstring [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_600, sizeof(symbol_600)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_601, sizeof(symbol_601)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(action_39, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    nlookahead_pos = parse_state->pos;
+    _ = rule_quote(parse_state);
+    if (_ == NULL) {
+        _ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);
+    } else {
+        _ = NULL;
+    }
+    parse_state->pos = nlookahead_pos;
+    if (_) {
+        if (parse_state->pos < parse_state->input_buffer->size) {
+            parse_state->pos += 1;
+            _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);
+        } else {
+            _ = NULL;
+        }
+        if (_) {
+            return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail innercharstring [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_nameAsSymbol(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule nameAsSymbol [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_name(parse_state);
+    append_named_action(variables, buffer_from_cstring(symbol_603, sizeof(symbol_603)-1), _);
+    if (_) {
+        return create_action(action_40, variables, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail nameAsSymbol [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_name(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule name [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    _ = rule_char(parse_state);
+    if (_) {
+        star_variables = create_variables();
+        star_start_pos = parse_state->pos;
+        while (1) {
+            star_pos = parse_state->pos;
+            _ = rule_char(parse_state);
+            if (_ == NULL) {
+                parse_state->pos = star_pos;
+                break;
+            }
+            append_named_action(star_variables, NULL, _);
+        }
+        fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+        _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+        if (_) {
+            return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+        }
+    }
+    fprintf(stderr, "debug: rule fail name [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_char(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule char [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_611, sizeof(symbol_611)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_612, sizeof(symbol_612)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_613, sizeof(symbol_613)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_614, sizeof(symbol_614)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_615, sizeof(symbol_615)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_616, sizeof(symbol_616)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_617, sizeof(symbol_617)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_618, sizeof(symbol_618)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_619, sizeof(symbol_619)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_620, sizeof(symbol_620)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_621, sizeof(symbol_621)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_622, sizeof(symbol_622)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_623, sizeof(symbol_623)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_624, sizeof(symbol_624)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_625, sizeof(symbol_625)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_626, sizeof(symbol_626)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_627, sizeof(symbol_627)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_628, sizeof(symbol_628)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_629, sizeof(symbol_629)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_630, sizeof(symbol_630)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_631, sizeof(symbol_631)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_632, sizeof(symbol_632)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_633, sizeof(symbol_633)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_634, sizeof(symbol_634)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_635, sizeof(symbol_635)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_636, sizeof(symbol_636)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_637, sizeof(symbol_637)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_638, sizeof(symbol_638)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_639, sizeof(symbol_639)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_640, sizeof(symbol_640)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_641, sizeof(symbol_641)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_642, sizeof(symbol_642)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_643, sizeof(symbol_643)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_644, sizeof(symbol_644)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_645, sizeof(symbol_645)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_646, sizeof(symbol_646)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_647, sizeof(symbol_647)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_648, sizeof(symbol_648)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_649, sizeof(symbol_649)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_650, sizeof(symbol_650)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_651, sizeof(symbol_651)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_652, sizeof(symbol_652)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_653, sizeof(symbol_653)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_654, sizeof(symbol_654)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_655, sizeof(symbol_655)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_656, sizeof(symbol_656)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_657, sizeof(symbol_657)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_658, sizeof(symbol_658)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_659, sizeof(symbol_659)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_660, sizeof(symbol_660)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_661, sizeof(symbol_661)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_662, sizeof(symbol_662)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail char [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_space(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule space [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    star_variables = create_variables();
+    star_start_pos = parse_state->pos;
+    while (1) {
+        star_pos = parse_state->pos;
+        _ = rule_spacechar(parse_state);
+        if (_ == NULL) {
+            parse_state->pos = star_pos;
+            break;
+        }
+        append_named_action(star_variables, NULL, _);
+    }
+    fprintf(stderr, "debug: creating_star [%d, %d, %p]\n", star_start_pos, parse_state->pos, star_variables->pre_first->next);
+    _ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail space [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+struct Action* rule_spacechar(struct ParseState* parse_state) {
+    unsigned int or_backtrack_pos;
+    unsigned int action_start_pos;
+    unsigned int star_start_pos;
+    unsigned int star_pos;
+    unsigned int nlookahead_pos;
+    struct Variables* variables;
+    struct Variables* star_variables;
+    struct Action* _;
+    struct Buffer* data;
+    fprintf(stderr, "debug: rule spacechar [pos=%d]\n", parse_state->pos);
+    or_backtrack_pos = parse_state->pos;
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_663, sizeof(symbol_663)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    parse_state->pos = or_backtrack_pos;
+    action_start_pos = parse_state->pos;
+    variables = create_variables();
+    data = buffer_from_cstring(symbol_664, sizeof(symbol_664)-1);
+    if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {
+        parse_state->pos += data->size;
+        _ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);
+    } else {
+        _ = NULL;
+    }
+    if (_) {
+        return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);
+    }
+    fprintf(stderr, "debug: rule fail spacechar [pos=%d]\n", parse_state->pos);
+    return NULL;
+}
+
+int main(void) {
+    arena_limit = 2<<30;
+    arena_pos = 0;
+    arena = malloc(arena_limit);
+    struct ParseState* parse_state = create_parse_state_from_stdin();
+    char last_char = '\n';
+    int indent = 0;
+    fprintf(stderr, parse_state->input_buffer->buffer);
+    struct Runtime* runtime = create_runtime();
+    struct Action* action = rule_main(parse_state);
+    struct Placeholder* placeholder;
+    if (action == NULL) {
+        fprintf(stderr, "ERROR: parse error [pos=%d] [size=%d]", parse_state->pos, parse_state->input_buffer->size);
+        exit(1);
+    }
+    run_action(action, runtime);
+    placeholder = runtime->placeholders->pre_first->next;
+    while (placeholder) {
+        runtime->current_chunks = placeholder->chunks;
+        run_action(placeholder->action, runtime);
+        placeholder = placeholder->next;
+    }
+    fprintf(stderr, "debug: arena memory = %p\n", arena);
+    fprintf(stderr, "debug: arena limit  = %u\n", arena_limit);
+    fprintf(stderr, "debug: arena used   = %u\n", arena_pos);
+    render_chunks(runtime->main_chunks, &last_char, &indent);
+}
diff --git a/08_translate_to_c/rlmeta2.py b/08_translate_to_c/rlmeta2.py
deleted file mode 100644
index fb13a4a..0000000
--- a/08_translate_to_c/rlmeta2.py
+++ /dev/null
@@ -1,2399 +0,0 @@
-import sys
-
-class ParseState:
-    input_buffer = None
-    pos = None
-
-class Runtime:
-    main_chunks = None
-    named_chunks_namedChunks = None
-    named_chunks_namedWs = None
-    named_chunks_actions = None
-    named_chunks_placeholders = None
-    current_chunks = None
-    W_0 = None
-    W_1 = None
-    placeholders = None
-
-class Action:
-    function = None
-    variables = None
-    input_buffer = None
-    start = None
-    end = None
-    len = None
-
-class Variables:
-    pre_first = None
-    last = None
-
-class Variable:
-    next = None
-    name = None
-    action = None
-
-class Chunks:
-    pre_first = None
-    last = None
-    seen = None
-
-class Chunk:
-    next = None
-    data = None
-    chunks = None
-    indentation_delta = None
-
-class Placeholders:
-    pre_first = None
-    last = None
-
-class Placeholder:
-    next = None
-    chunks = None
-    action = None
-
-def create_parse_state_from_stdin():
-    parse_state = ParseState()
-    parse_state.input_buffer = sys.stdin.buffer.read()
-    parse_state.pos = 0
-    return parse_state
-
-def create_runtime():
-    runtime = Runtime()
-    runtime.main_chunks = create_chunks()
-    runtime.current_chunks = runtime.main_chunks
-    runtime.placeholders = create_placeholders()
-    return runtime
-
-def create_action(function, variables, input_buffer, start, end):
-    action = Action()
-    action.function = function
-    action.variables = variables
-    action.input_buffer = input_buffer
-    action.start = start
-    action.end = end
-    action.len = end-start
-    return action
-
-def create_variables():
-    variables = Variables()
-    variables.pre_first = Variable()
-    variables.last = variables.pre_first
-    return variables
-
-def create_chunks():
-    chunks = Chunks()
-    chunks.pre_first = Chunk()
-    chunks.last = chunks.pre_first
-    return chunks
-
-def create_placeholders():
-    placeholders = Placeholder()
-    placeholders.pre_first = Placeholder()
-    placeholders.last = placeholders.pre_first
-    return placeholders
-
-def run_action(action, runtime):
-    if action.function is None:
-        if action.variables is None:
-            append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)
-        else:
-            variable = action.variables.pre_first.next
-            while variable:
-                run_action(variable.action, runtime)
-                variable = variable.next
-    else:
-        action.function(runtime, action.variables)
-
-def append_data(chunks, data, indentation_delta, sub_chunks=None):
-    chunk = Chunk()
-    chunk.next = None
-    chunk.data = data
-    chunk.chunks = sub_chunks
-    chunk.indentation_delta = indentation_delta
-    chunks.last.next = chunk
-    chunks.last = chunk
-
-def seen(chunks, data):
-    chunk = chunks.pre_first.next
-    while chunk:
-        if chunk.data == data:
-            return True
-        chunk = chunk.next
-    return False
-
-def append_named_action(variables, name, action):
-    next_variable = Variable()
-    next_variable.next = None
-    next_variable.name = name
-    next_variable.action = action
-    variables.last.next = next_variable
-    variables.last = next_variable
-
-def lookup_action(variables, name_to_look_for):
-    variable = variables.pre_first.next
-    while variable:
-        if variable.name == name_to_look_for:
-            return variable.action
-        else:
-            variable = variable.next
-    raise ValueError(f'variable {name_to_look_for} not found')
-
-def append_placeholder(placeholders, chunks, action):
-    next_variable = Placeholder()
-    next_variable.next = None
-    next_variable.chunks = chunks
-    next_variable.action = action
-    placeholders.last.next = next_variable
-    placeholders.last = next_variable
-
-def inc(value, amount):
-    return value + amount
-
-def render_chunks(chunks, last_char=b'\n', indent=0):
-    if chunks:
-        chunk = chunks.pre_first.next
-        while chunk:
-            indent += chunk.indentation_delta
-            for char in chunk.data:
-                if last_char == b'\n':
-                    sys.stdout.buffer.write(b'    '*indent)
-                last_char = char.to_bytes()
-                sys.stdout.buffer.write(last_char)
-            last_char, indent = render_chunks(chunk.chunks, last_char, indent)
-            chunk = chunk.next
-    return last_char, indent
-
-ERROR = -1
-
-def action_1(runtime, variables):
-    pass
-    run_action(lookup_action(variables, 'x'), runtime)
-
-def action_2(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"import sys\n", 0)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class ParseState:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"input_buffer = None\n", 0)
-    append_data(runtime.current_chunks, b"pos = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Runtime:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"main_chunks = None\n", 0)
-    chunks = create_chunks()
-    runtime.named_chunks_namedChunks = chunks
-    append_data(runtime.current_chunks, b'', 0, chunks)
-    append_data(runtime.current_chunks, b"current_chunks = None\n", 0)
-    chunks = create_chunks()
-    runtime.named_chunks_namedWs = chunks
-    append_data(runtime.current_chunks, b'', 0, chunks)
-    append_data(runtime.current_chunks, b"placeholders = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Action:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"function = None\n", 0)
-    append_data(runtime.current_chunks, b"variables = None\n", 0)
-    append_data(runtime.current_chunks, b"input_buffer = None\n", 0)
-    append_data(runtime.current_chunks, b"start = None\n", 0)
-    append_data(runtime.current_chunks, b"end = None\n", 0)
-    append_data(runtime.current_chunks, b"len = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Variables:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
-    append_data(runtime.current_chunks, b"last = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Variable:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"next = None\n", 0)
-    append_data(runtime.current_chunks, b"name = None\n", 0)
-    append_data(runtime.current_chunks, b"action = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Chunks:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
-    append_data(runtime.current_chunks, b"last = None\n", 0)
-    append_data(runtime.current_chunks, b"seen = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Chunk:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"next = None\n", 0)
-    append_data(runtime.current_chunks, b"data = None\n", 0)
-    append_data(runtime.current_chunks, b"chunks = None\n", 0)
-    append_data(runtime.current_chunks, b"indentation_delta = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Placeholders:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
-    append_data(runtime.current_chunks, b"last = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class Placeholder:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"next = None\n", 0)
-    append_data(runtime.current_chunks, b"chunks = None\n", 0)
-    append_data(runtime.current_chunks, b"action = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def create_parse_state_from_stdin():\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"parse_state = ParseState()\n", 0)
-    append_data(runtime.current_chunks, b"parse_state.input_buffer = sys.stdin.buffer.read()\n", 0)
-    append_data(runtime.current_chunks, b"parse_state.pos = 0\n", 0)
-    append_data(runtime.current_chunks, b"return parse_state\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def create_runtime():\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"runtime = Runtime()\n", 0)
-    append_data(runtime.current_chunks, b"runtime.main_chunks = create_chunks()\n", 0)
-    append_data(runtime.current_chunks, b"runtime.current_chunks = runtime.main_chunks\n", 0)
-    append_data(runtime.current_chunks, b"runtime.placeholders = create_placeholders()\n", 0)
-    append_data(runtime.current_chunks, b"return runtime\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def create_action(function, variables, input_buffer, start, end):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"action = Action()\n", 0)
-    append_data(runtime.current_chunks, b"action.function = function\n", 0)
-    append_data(runtime.current_chunks, b"action.variables = variables\n", 0)
-    append_data(runtime.current_chunks, b"action.input_buffer = input_buffer\n", 0)
-    append_data(runtime.current_chunks, b"action.start = start\n", 0)
-    append_data(runtime.current_chunks, b"action.end = end\n", 0)
-    append_data(runtime.current_chunks, b"action.len = end-start\n", 0)
-    append_data(runtime.current_chunks, b"return action\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def create_variables():\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"variables = Variables()\n", 0)
-    append_data(runtime.current_chunks, b"variables.pre_first = Variable()\n", 0)
-    append_data(runtime.current_chunks, b"variables.last = variables.pre_first\n", 0)
-    append_data(runtime.current_chunks, b"return variables\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def create_chunks():\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"chunks = Chunks()\n", 0)
-    append_data(runtime.current_chunks, b"chunks.pre_first = Chunk()\n", 0)
-    append_data(runtime.current_chunks, b"chunks.last = chunks.pre_first\n", 0)
-    append_data(runtime.current_chunks, b"return chunks\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def create_placeholders():\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"placeholders = Placeholder()\n", 0)
-    append_data(runtime.current_chunks, b"placeholders.pre_first = Placeholder()\n", 0)
-    append_data(runtime.current_chunks, b"placeholders.last = placeholders.pre_first\n", 0)
-    append_data(runtime.current_chunks, b"return placeholders\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def run_action(action, runtime):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"if action.function is None:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"if action.variables is None:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"else:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"variable = action.variables.pre_first.next\n", 0)
-    append_data(runtime.current_chunks, b"while variable:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"run_action(variable.action, runtime)\n", 0)
-    append_data(runtime.current_chunks, b"variable = variable.next\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"else:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"action.function(runtime, action.variables)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def append_data(chunks, data, indentation_delta, sub_chunks=None):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"chunk = Chunk()\n", 0)
-    append_data(runtime.current_chunks, b"chunk.next = None\n", 0)
-    append_data(runtime.current_chunks, b"chunk.data = data\n", 0)
-    append_data(runtime.current_chunks, b"chunk.chunks = sub_chunks\n", 0)
-    append_data(runtime.current_chunks, b"chunk.indentation_delta = indentation_delta\n", 0)
-    append_data(runtime.current_chunks, b"chunks.last.next = chunk\n", 0)
-    append_data(runtime.current_chunks, b"chunks.last = chunk\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def seen(chunks, data):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"chunk = chunks.pre_first.next\n", 0)
-    append_data(runtime.current_chunks, b"while chunk:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"if chunk.data == data:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"return True\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"chunk = chunk.next\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"return False\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def append_named_action(variables, name, action):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"next_variable = Variable()\n", 0)
-    append_data(runtime.current_chunks, b"next_variable.next = None\n", 0)
-    append_data(runtime.current_chunks, b"next_variable.name = name\n", 0)
-    append_data(runtime.current_chunks, b"next_variable.action = action\n", 0)
-    append_data(runtime.current_chunks, b"variables.last.next = next_variable\n", 0)
-    append_data(runtime.current_chunks, b"variables.last = next_variable\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def lookup_action(variables, name_to_look_for):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"variable = variables.pre_first.next\n", 0)
-    append_data(runtime.current_chunks, b"while variable:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"if variable.name == name_to_look_for:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"return variable.action\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"else:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"variable = variable.next\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def append_placeholder(placeholders, chunks, action):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"next_variable = Placeholder()\n", 0)
-    append_data(runtime.current_chunks, b"next_variable.next = None\n", 0)
-    append_data(runtime.current_chunks, b"next_variable.chunks = chunks\n", 0)
-    append_data(runtime.current_chunks, b"next_variable.action = action\n", 0)
-    append_data(runtime.current_chunks, b"placeholders.last.next = next_variable\n", 0)
-    append_data(runtime.current_chunks, b"placeholders.last = next_variable\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def inc(value, amount):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"return value + amount\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"def render_chunks(chunks, last_char=b'\\n', indent=0):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"if chunks:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"chunk = chunks.pre_first.next\n", 0)
-    append_data(runtime.current_chunks, b"while chunk:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"indent += chunk.indentation_delta\n", 0)
-    append_data(runtime.current_chunks, b"for char in chunk.data:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"if last_char == b'\\n':\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"sys.stdout.buffer.write(b'    '*indent)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"last_char = char.to_bytes()\n", 0)
-    append_data(runtime.current_chunks, b"sys.stdout.buffer.write(last_char)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"last_char, indent = render_chunks(chunk.chunks, last_char, indent)\n", 0)
-    append_data(runtime.current_chunks, b"chunk = chunk.next\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"return last_char, indent\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"ERROR = -1\n", 0)
-    append_data(runtime.current_chunks, b"\n", 0)
-    chunks = create_chunks()
-    runtime.named_chunks_actions = chunks
-    append_data(runtime.current_chunks, b'', 0, chunks)
-    chunks = create_chunks()
-    runtime.named_chunks_placeholders = chunks
-    append_data(runtime.current_chunks, b'', 0, chunks)
-    run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunks, b"if __name__ == '__main__':\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"parse_state = create_parse_state_from_stdin()\n", 0)
-    append_data(runtime.current_chunks, b"runtime = create_runtime()\n", 0)
-    append_data(runtime.current_chunks, b"action = rule_main(parse_state)\n", 0)
-    append_data(runtime.current_chunks, b"if action == ERROR:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"sys.exit('Parse error')\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"run_action(action, runtime)\n", 0)
-    append_data(runtime.current_chunks, b"placeholder = runtime.placeholders.pre_first.next\n", 0)
-    append_data(runtime.current_chunks, b"while placeholder:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"runtime.current_chunks = placeholder.chunks\n", 0)
-    append_data(runtime.current_chunks, b"run_action(placeholder.action, runtime)\n", 0)
-    append_data(runtime.current_chunks, b"placeholder = placeholder.next\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"render_chunks(runtime.main_chunks)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-
-def action_3(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"def rule_", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"(parse_state):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-
-def action_4(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"or_backtrack_pos = parse_state.pos\n", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunks, b"return ERROR\n", 0)
-
-def action_5(runtime, variables):
-    pass
-    run_action(lookup_action(variables, 'x'), runtime)
-
-def action_6(runtime, variables):
-    pass
-
-def action_7(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"parse_state.pos = or_backtrack_pos\n", 0)
-    append_data(runtime.current_chunks, b"action_start_pos = parse_state.pos\n", 0)
-    append_data(runtime.current_chunks, b"variables = create_variables()\n", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-
-def action_8(runtime, variables):
-    pass
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"if _ != ERROR:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunks, b'', -1)
-
-def action_9(runtime, variables):
-    pass
-    run_action(lookup_action(variables, 'y'), runtime)
-
-def action_10(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"nlookahead_pos = parse_state.pos\n", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"if _ == ERROR:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"_ = lambda: None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"else:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"parse_state.pos = nlookahead_pos\n", 0)
-
-def action_11(runtime, variables):
-    pass
-    run_action(lookup_action(variables, 'x'), runtime)
-    run_action(lookup_action(variables, 'y'), runtime)
-
-def action_12(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"append_named_action(variables, '", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"', _)\n", 0)
-
-def action_13(runtime, variables):
-    pass
-
-def action_14(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"star_variables = create_variables()\n", 0)
-    append_data(runtime.current_chunks, b"star_start_pos = parse_state.pos\n", 0)
-    append_data(runtime.current_chunks, b"while True:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"star_pos = parse_state.pos\n", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"if _ == ERROR:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"parse_state.pos = star_pos\n", 0)
-    append_data(runtime.current_chunks, b"break\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"append_named_action(star_variables, None, _)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
-
-def action_15(runtime, variables):
-    pass
-    run_action(lookup_action(variables, 'x'), runtime)
-
-def action_16(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"_ = rule_", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"(parse_state)\n", 0)
-
-def action_17(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"parse_state.pos += 1\n", 0)
-    append_data(runtime.current_chunks, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"else:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-
-def action_18(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"data = b", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"parse_state.pos += len(data)\n", 0)
-    append_data(runtime.current_chunks, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"else:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-
-def action_19(runtime, variables):
-    pass
-    runtime.W_0 = inc(runtime.W_0 or 0, 1)
-    last_chunks = runtime.current_chunks
-    chunks = runtime.named_chunks_actions
-    runtime.current_chunks = chunks
-    append_data(runtime.current_chunks, b"def action_", 0)
-    append_data(runtime.current_chunks, str((runtime.W_0 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunks, b"(runtime, variables):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"pass\n", 0)
-    run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    runtime.current_chunks = last_chunks
-    append_data(runtime.current_chunks, b"return create_action(action_", 0)
-    append_data(runtime.current_chunks, str((runtime.W_0 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunks, b", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
-
-def action_20(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
-
-def action_21(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"action = lookup_action(variables, '", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"')\n", 0)
-    append_data(runtime.current_chunks, b"if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"pass\n", 0)
-    run_action(lookup_action(variables, 'ys'), runtime)
-    append_data(runtime.current_chunks, b'', -1)
-
-def action_22(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"last_chunks = runtime.current_chunks\n", 0)
-    append_data(runtime.current_chunks, b"chunks = runtime.named_chunks_", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"runtime.current_chunks = chunks\n", 0)
-    run_action(lookup_action(variables, 'ys'), runtime)
-    append_data(runtime.current_chunks, b"runtime.current_chunks = last_chunks\n", 0)
-
-def action_23(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"chunks = create_chunks()\n", 0)
-    append_data(runtime.current_chunks, b"runtime.named_chunks_", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b" = chunks\n", 0)
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 0, chunks)\n", 0)
-
-def action_24(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, str(", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b").encode('ascii'), 0)\n", 0)
-
-def action_25(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"run_action(lookup_action(variables, '", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"'), runtime)\n", 0)
-
-def action_26(runtime, variables):
-    pass
-    runtime.W_1 = inc(runtime.W_1 or 0, 1)
-    last_chunks = runtime.current_chunks
-    chunks = runtime.named_chunks_placeholders
-    runtime.current_chunks = chunks
-    append_data(runtime.current_chunks, b"def placeholder_", 0)
-    append_data(runtime.current_chunks, str((runtime.W_1 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunks, b"(runtime, variables):\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"pass\n", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
-    runtime.current_chunks = last_chunks
-    append_data(runtime.current_chunks, b"chunks = create_chunks()\n", 0)
-    append_data(runtime.current_chunks, b"append_placeholder(runtime.placeholders, chunks, create_action(placeholder_", 0)
-    append_data(runtime.current_chunks, str((runtime.W_1 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunks, b", variables, '', 0, 0))\n", 0)
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 0, chunks)\n", 0)
-
-def action_27(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b", 0)\n", 0)
-
-def action_28(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"runtime.W_", 0)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunks, b" = ", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"(runtime.W_", 0)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunks, b" or 0, ", 0)
-    run_action(lookup_action(variables, 'z'), runtime)
-    append_data(runtime.current_chunks, b")\n", 0)
-
-def action_29(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 1)\n", 0)
-    run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', -1)\n", 0)
-
-def action_30(runtime, variables):
-    pass
-    last_chunks = runtime.current_chunks
-    chunks = runtime.named_chunks_namedChunks
-    runtime.current_chunks = chunks
-    action = lookup_action(variables, 'x')
-    if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):
-        pass
-        append_data(runtime.current_chunks, b"named_chunks_", 0)
-        run_action(lookup_action(variables, 'x'), runtime)
-        append_data(runtime.current_chunks, b" = None\n", 0)
-    runtime.current_chunks = last_chunks
-    run_action(lookup_action(variables, 'x'), runtime)
-
-def action_31(runtime, variables):
-    pass
-    run_action(lookup_action(variables, 'x'), runtime)
-
-def action_32(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"*", 0)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunks, b", 0)\n", 0)
-
-def action_33(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"(runtime.W_", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b" or 0)", 0)
-
-def action_34(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"((runtime.W_", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b" or 0)-", 0)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunks, b")", 0)
-
-def action_35(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"lookup_action(variables, '", 0)
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunks, b"')", 0)
-    run_action(lookup_action(variables, 'xs'), runtime)
-
-def action_36(runtime, variables):
-    pass
-    last_chunks = runtime.current_chunks
-    chunks = runtime.named_chunks_namedWs
-    runtime.current_chunks = chunks
-    action = lookup_action(variables, 'x')
-    if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):
-        pass
-        append_data(runtime.current_chunks, b"W_", 0)
-        run_action(lookup_action(variables, 'x'), runtime)
-        append_data(runtime.current_chunks, b" = None\n", 0)
-    runtime.current_chunks = last_chunks
-    run_action(lookup_action(variables, 'x'), runtime)
-
-def rule_main(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_file(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_1, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_file(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    star_variables = create_variables()
-    star_start_pos = parse_state.pos
-    while True:
-        star_pos = parse_state.pos
-        _ = rule_rule(parse_state)
-        if _ == ERROR:
-            parse_state.pos = star_pos
-            break
-        append_named_action(star_variables, None, _)
-    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-    append_named_action(variables, 'xs', _)
-    if _ != ERROR:
-        _ = rule_space(parse_state)
-        if _ != ERROR:
-            nlookahead_pos = parse_state.pos
-            if parse_state.pos != len(parse_state.input_buffer):
-                parse_state.pos += 1
-                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
-            else:
-                _ = ERROR
-            if _ == ERROR:
-                _ = lambda: None
-            else:
-                _ = ERROR
-            parse_state.pos = nlookahead_pos
-            if _ != ERROR:
-                return create_action(action_2, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_rule(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        _ = rule_name(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            _ = rule_space(parse_state)
-            if _ != ERROR:
-                data = b'='
-                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                    parse_state.pos += len(data)
-                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                else:
-                    _ = ERROR
-                if _ != ERROR:
-                    _ = rule_space(parse_state)
-                    if _ != ERROR:
-                        _ = rule_ors(parse_state)
-                        append_named_action(variables, 'y', _)
-                        if _ != ERROR:
-                            _ = rule_space(parse_state)
-                            if _ != ERROR:
-                                data = b';'
-                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                                    parse_state.pos += len(data)
-                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                                else:
-                                    _ = ERROR
-                                if _ != ERROR:
-                                    return create_action(action_3, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_ors(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_maybeorbar(parse_state)
-    if _ != ERROR:
-        _ = rule_orcase(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            star_variables = create_variables()
-            star_start_pos = parse_state.pos
-            while True:
-                star_pos = parse_state.pos
-                _ = rule_restorcase(parse_state)
-                if _ == ERROR:
-                    parse_state.pos = star_pos
-                    break
-                append_named_action(star_variables, None, _)
-            _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-            append_named_action(variables, 'xs', _)
-            if _ != ERROR:
-                return create_action(action_4, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_restorcase(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_orbar(parse_state)
-    if _ != ERROR:
-        _ = rule_orcase(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            return create_action(action_5, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_maybeorbar(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_orbar(parse_state)
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    return create_action(action_6, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_orbar(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        data = b'|'
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_orcase(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_matchAnd(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_7, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_matchAnd(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        _ = rule_matchExpr(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            _ = rule_matchAnd(parse_state)
-            append_named_action(variables, 'y', _)
-            if _ != ERROR:
-                return create_action(action_8, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_action(parse_state)
-    append_named_action(variables, 'y', _)
-    if _ != ERROR:
-        return create_action(action_9, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_matchExpr(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'!'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        _ = rule_matchExprPrimitive(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            return create_action(action_10, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_matchExprRepeat(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        _ = rule_matchAssign(parse_state)
-        append_named_action(variables, 'y', _)
-        if _ != ERROR:
-            return create_action(action_11, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_matchAssign(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b':'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        _ = rule_name(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            return create_action(action_12, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    return create_action(action_13, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_matchExprRepeat(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_matchExprPrimitive(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        data = b'*'
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            return create_action(action_14, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_matchExprPrimitive(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_15, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_matchExprPrimitive(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_name(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_16, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'.'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(action_17, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_charstring(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_18, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_action(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        data = b'->'
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            _ = rule_space(parse_state)
-            if _ != ERROR:
-                data = b'{'
-                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                    parse_state.pos += len(data)
-                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                else:
-                    _ = ERROR
-                if _ != ERROR:
-                    star_variables = create_variables()
-                    star_start_pos = parse_state.pos
-                    while True:
-                        star_pos = parse_state.pos
-                        _ = rule_actionexpr(parse_state)
-                        if _ == ERROR:
-                            parse_state.pos = star_pos
-                            break
-                        append_named_action(star_variables, None, _)
-                    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-                    append_named_action(variables, 'xs', _)
-                    if _ != ERROR:
-                        _ = rule_space(parse_state)
-                        if _ != ERROR:
-                            data = b'}'
-                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                                parse_state.pos += len(data)
-                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                            else:
-                                _ = ERROR
-                            if _ != ERROR:
-                                return create_action(action_19, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    return create_action(action_20, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_actionexpr(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        data = b'unseen('
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            _ = rule_name(parse_state)
-            append_named_action(variables, 'x', _)
-            if _ != ERROR:
-                data = b') -> {'
-                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                    parse_state.pos += len(data)
-                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                else:
-                    _ = ERROR
-                if _ != ERROR:
-                    star_variables = create_variables()
-                    star_start_pos = parse_state.pos
-                    while True:
-                        star_pos = parse_state.pos
-                        _ = rule_actionexpr(parse_state)
-                        if _ == ERROR:
-                            parse_state.pos = star_pos
-                            break
-                        append_named_action(star_variables, None, _)
-                    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-                    append_named_action(variables, 'ys', _)
-                    if _ != ERROR:
-                        _ = rule_space(parse_state)
-                        if _ != ERROR:
-                            data = b'}'
-                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                                parse_state.pos += len(data)
-                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                            else:
-                                _ = ERROR
-                            if _ != ERROR:
-                                return create_action(action_21, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        data = b'>'
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            _ = rule_chunkName(parse_state)
-            append_named_action(variables, 'x', _)
-            if _ != ERROR:
-                _ = rule_space(parse_state)
-                if _ != ERROR:
-                    data = b'{'
-                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                        parse_state.pos += len(data)
-                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                    else:
-                        _ = ERROR
-                    if _ != ERROR:
-                        star_variables = create_variables()
-                        star_start_pos = parse_state.pos
-                        while True:
-                            star_pos = parse_state.pos
-                            _ = rule_actionexpr(parse_state)
-                            if _ == ERROR:
-                                parse_state.pos = star_pos
-                                break
-                            append_named_action(star_variables, None, _)
-                        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-                        append_named_action(variables, 'ys', _)
-                        if _ != ERROR:
-                            _ = rule_space(parse_state)
-                            if _ != ERROR:
-                                data = b'}'
-                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                                    parse_state.pos += len(data)
-                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                                else:
-                                    _ = ERROR
-                                if _ != ERROR:
-                                    return create_action(action_22, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        data = b'<'
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            _ = rule_chunkName(parse_state)
-            append_named_action(variables, 'x', _)
-            if _ != ERROR:
-                return create_action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        _ = rule_expr(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            return create_action(action_24, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        _ = rule_name(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            return create_action(action_25, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        _ = rule_placeholder(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            return create_action(action_26, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        _ = rule_string(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            return create_action(action_27, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        data = b'#'
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            _ = rule_name(parse_state)
-            append_named_action(variables, 'x', _)
-            if _ != ERROR:
-                data = b'('
-                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                    parse_state.pos += len(data)
-                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                else:
-                    _ = ERROR
-                if _ != ERROR:
-                    _ = rule_wvar(parse_state)
-                    append_named_action(variables, 'y', _)
-                    if _ != ERROR:
-                        data = b' '
-                        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                            parse_state.pos += len(data)
-                            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                        else:
-                            _ = ERROR
-                        if _ != ERROR:
-                            _ = rule_actionPrimitiveExpression(parse_state)
-                            append_named_action(variables, 'z', _)
-                            if _ != ERROR:
-                                data = b')'
-                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                                    parse_state.pos += len(data)
-                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                                else:
-                                    _ = ERROR
-                                if _ != ERROR:
-                                    return create_action(action_28, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_space(parse_state)
-    if _ != ERROR:
-        data = b'>'
-        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-            parse_state.pos += len(data)
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            star_variables = create_variables()
-            star_start_pos = parse_state.pos
-            while True:
-                star_pos = parse_state.pos
-                _ = rule_actionexpr(parse_state)
-                if _ == ERROR:
-                    parse_state.pos = star_pos
-                    break
-                append_named_action(star_variables, None, _)
-            _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-            append_named_action(variables, 'xs', _)
-            if _ != ERROR:
-                _ = rule_space(parse_state)
-                if _ != ERROR:
-                    data = b'<'
-                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                        parse_state.pos += len(data)
-                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                    else:
-                        _ = ERROR
-                    if _ != ERROR:
-                        return create_action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_chunkName(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_name(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_actionPrimitiveExpression(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_dotname(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_digit(parse_state)
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_digit(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'0'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'1'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'2'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'3'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'4'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'5'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'6'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'7'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'8'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'9'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_placeholder(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'{'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        _ = rule_space(parse_state)
-        if _ != ERROR:
-            _ = rule_string(parse_state)
-            append_named_action(variables, 'x', _)
-            if _ != ERROR:
-                data = b'*'
-                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                    parse_state.pos += len(data)
-                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                else:
-                    _ = ERROR
-                if _ != ERROR:
-                    _ = rule_expr(parse_state)
-                    append_named_action(variables, 'y', _)
-                    if _ != ERROR:
-                        _ = rule_space(parse_state)
-                        if _ != ERROR:
-                            data = b'}'
-                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                                parse_state.pos += len(data)
-                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                            else:
-                                _ = ERROR
-                            if _ != ERROR:
-                                return create_action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_expr(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_wvar(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        return create_action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'('
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        _ = rule_wvar(parse_state)
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            data = b'-'
-            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                parse_state.pos += len(data)
-                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-            else:
-                _ = ERROR
-            if _ != ERROR:
-                _ = rule_dotname(parse_state)
-                append_named_action(variables, 'y', _)
-                if _ != ERROR:
-                    data = b')'
-                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                        parse_state.pos += len(data)
-                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-                    else:
-                        _ = ERROR
-                    if _ != ERROR:
-                        return create_action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_string(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'"'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        star_variables = create_variables()
-        star_start_pos = parse_state.pos
-        while True:
-            star_pos = parse_state.pos
-            _ = rule_stringinner(parse_state)
-            if _ == ERROR:
-                parse_state.pos = star_pos
-                break
-            append_named_action(star_variables, None, _)
-        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-        if _ != ERROR:
-            data = b'"'
-            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                parse_state.pos += len(data)
-                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-            else:
-                _ = ERROR
-            if _ != ERROR:
-                return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_dotname(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_name(parse_state)
-    append_named_action(variables, 'x', _)
-    if _ != ERROR:
-        star_variables = create_variables()
-        star_start_pos = parse_state.pos
-        while True:
-            star_pos = parse_state.pos
-            _ = rule_nextname(parse_state)
-            if _ == ERROR:
-                parse_state.pos = star_pos
-                break
-            append_named_action(star_variables, None, _)
-        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-        append_named_action(variables, 'xs', _)
-        if _ != ERROR:
-            return create_action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_nextname(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'.'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        _ = rule_name(parse_state)
-        if _ != ERROR:
-            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_wvar(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'W['
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        if parse_state.pos != len(parse_state.input_buffer):
-            parse_state.pos += 1
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
-        else:
-            _ = ERROR
-        append_named_action(variables, 'x', _)
-        if _ != ERROR:
-            data = b']'
-            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-                parse_state.pos += len(data)
-                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-            else:
-                _ = ERROR
-            if _ != ERROR:
-                return create_action(action_36, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_stringinner(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'\\"'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    nlookahead_pos = parse_state.pos
-    _ = rule_stringend(parse_state)
-    if _ == ERROR:
-        _ = lambda: None
-    else:
-        _ = ERROR
-    parse_state.pos = nlookahead_pos
-    if _ != ERROR:
-        if parse_state.pos != len(parse_state.input_buffer):
-            parse_state.pos += 1
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_stringend(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'"'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_charstring(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_quote(parse_state)
-    if _ != ERROR:
-        star_variables = create_variables()
-        star_start_pos = parse_state.pos
-        while True:
-            star_pos = parse_state.pos
-            _ = rule_innercharstring(parse_state)
-            if _ == ERROR:
-                parse_state.pos = star_pos
-                break
-            append_named_action(star_variables, None, _)
-        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-        if _ != ERROR:
-            _ = rule_quote(parse_state)
-            if _ != ERROR:
-                return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_quote(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'\''
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_innercharstring(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'\\\''
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    nlookahead_pos = parse_state.pos
-    _ = rule_quote(parse_state)
-    if _ == ERROR:
-        _ = lambda: None
-    else:
-        _ = ERROR
-    parse_state.pos = nlookahead_pos
-    if _ != ERROR:
-        if parse_state.pos != len(parse_state.input_buffer):
-            parse_state.pos += 1
-            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
-        else:
-            _ = ERROR
-        if _ != ERROR:
-            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_name(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    _ = rule_char(parse_state)
-    if _ != ERROR:
-        star_variables = create_variables()
-        star_start_pos = parse_state.pos
-        while True:
-            star_pos = parse_state.pos
-            _ = rule_char(parse_state)
-            if _ == ERROR:
-                parse_state.pos = star_pos
-                break
-            append_named_action(star_variables, None, _)
-        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-        if _ != ERROR:
-            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_char(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'a'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'b'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'c'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'd'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'e'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'f'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'g'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'h'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'i'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'j'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'k'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'l'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'm'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'n'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'o'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'p'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'q'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'r'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b's'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b't'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'u'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'v'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'w'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'x'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'y'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'z'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'A'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'B'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'C'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'D'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'E'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'F'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'G'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'H'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'I'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'J'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'K'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'L'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'M'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'N'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'O'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'P'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'Q'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'R'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'S'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'T'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'U'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'V'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'W'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'X'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'Y'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'Z'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_space(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    star_variables = create_variables()
-    star_start_pos = parse_state.pos
-    while True:
-        star_pos = parse_state.pos
-        _ = rule_spacechar(parse_state)
-        if _ == ERROR:
-            parse_state.pos = star_pos
-            break
-        append_named_action(star_variables, None, _)
-    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-def rule_spacechar(parse_state):
-    or_backtrack_pos = parse_state.pos
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b' '
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    parse_state.pos = or_backtrack_pos
-    action_start_pos = parse_state.pos
-    variables = create_variables()
-    data = b'\n'
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
-        parse_state.pos += len(data)
-        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
-    else:
-        _ = ERROR
-    if _ != ERROR:
-        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
-    return ERROR
-
-if __name__ == '__main__':
-    parse_state = create_parse_state_from_stdin()
-    runtime = create_runtime()
-    action = rule_main(parse_state)
-    if action == ERROR:
-        sys.exit('Parse error')
-    run_action(action, runtime)
-    placeholder = runtime.placeholders.pre_first.next
-    while placeholder:
-        runtime.current_chunks = placeholder.chunks
-        run_action(placeholder.action, runtime)
-        placeholder = placeholder.next
-    render_chunks(runtime.main_chunks)
diff --git a/08_translate_to_c/test.sh b/08_translate_to_c/test.sh
index fd236db..146c9ac 100755
--- a/08_translate_to_c/test.sh
+++ b/08_translate_to_c/test.sh
@@ -7,27 +7,26 @@ cd "$(dirname "$0")"
 echo "Running experiments"
 gcc -o experiments experiments.c && ./experiments
 
-echo "Compiling rlmeta2_meta.py"
-python rlmeta2.py <rlmeta2.rlmeta2 >rlmeta2_meta.py
-python rlmeta2_meta.py <rlmeta2.rlmeta2 >rlmeta2_meta.c
-gcc -Wfatal-errors -o rlmeta2_meta rlmeta2_meta.c
-./rlmeta2_meta <rlmeta2.rlmeta2 >rlmeta2_meta_meta.c
-
-#echo "Is metacompiler? Diff rlmeta2_meta.py"
-#diff rlmeta2.py rlmeta2_meta.py
-#
-#echo "Compiling table.py"
-#python rlmeta2.py <table.rlmeta2 >table.py
-#
-#echo "Diffing"
-#if diff <(python table.py < table.txt) <(cat <<EOF
-#Name     Age
-#-------  ---
-#Rickard  40
-#Axel     7
-#EOF
-#); then
-#    echo Diff OK
-#fi
-#
-#python table.py < table.txt
+echo "Compiling rlmeta2_meta"
+gcc -Wfatal-errors -o rlmeta2 rlmeta2.c
+./rlmeta2 <rlmeta2.rlmeta2 >rlmeta2_meta.c
+
+echo "Is metacompiler? Diff rlmeta2_meta.c"
+diff rlmeta2.c rlmeta2_meta.c
+
+echo "Compiling table.py"
+./rlmeta2 <table.rlmeta2 >table.c
+gcc -Wfatal-errors -o table table.c
+
+echo "Diffing"
+if diff <(./table < table.txt) <(cat <<EOF
+Name     Age
+-------  ---
+Rickard  40
+Axel     7
+EOF
+); then
+    echo Diff OK
+fi
+
+./table < table.txt

2025-11-01 12:00 Rickard pushed to rlmeta2

commit f020e1b6d6d80bf889064458abaccf9257dee709
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 11:58:06 2025 +0100

    Fix the last parts!!!

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 947006c..8b6aa9b 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -95,7 +95,7 @@ file = rule*:xs space !. -> {
             "pos = allocate(1);\n"
             "parse_state->input_buffer->size++;\n"
         < "}\n"
-        "*pos = '\\0';\n"
+        "parse_state->input_buffer->size--;\n"
         "fprintf(stderr, \"debug: stdin data memory = %p\\n\", parse_state->input_buffer->buffer);\n"
         "return parse_state;\n"
     < "}\n"
@@ -179,9 +179,8 @@ file = rule*:xs space !. -> {
     "\n"
     "struct Buffer* buffer_from_integer(unsigned int value) {\n" >
         "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n"
-        "char format_string[] = {'%', 'd'};\n"
         "buffer->buffer = allocate(20);\n"
-        "sprintf(buffer->buffer, format_string, value);\n"
+        "sprintf(buffer->buffer, \"%d\", value);\n"
         "buffer->size = strlen(buffer->buffer);\n"
         "return buffer;\n"
     < "}\n"
@@ -205,7 +204,14 @@ file = rule*:xs space !. -> {
     < "}\n"
     "\n"
     "int compare_buffers(struct Buffer* b1, struct Buffer* b2) {\n" >
-        "if (b1->size != b2->size) return 0;"
+        "if (b1->size != b2->size) {\n" >
+            "return 0;\n"
+        < "}\n"
+        "for (int i=0; i<b1->size; i++) {\n" >
+            "if (b1->buffer[i] != b2->buffer[i]) {\n" >
+                "return 0;\n"
+            < "}\n"
+        < "}\n"
         "return 1;"
     < "}\n"
     "\n"

commit 73984175412fc70b9598a8134d36dc793599da0d
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 11:53:01 2025 +0100

    Fix potential mixup in of for render_chunks

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 995f2ca..947006c 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -192,14 +192,14 @@ file = rule*:xs space !. -> {
         < "} else {\n" >
             "if (action->variables) {\n" >
                 "fprintf(stderr, \"debug_run_action variables\\n\");\n"
-                "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n"
-            < "} else {\n" >
-                "fprintf(stderr, \"debug_run_action else\\n\");\n"
                 "struct Variable* variable = action->variables->pre_first->next;\n"
                 "while (variable) {\n" >
                     "run_action(variable->action, runtime);\n"
                     "variable = variable->next;\n"
                 < "}\n"
+            < "} else {\n" >
+                "fprintf(stderr, \"debug_run_action else\\n\");\n"
+                "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n"
             < "}\n"
         < "}\n"
     < "}\n"
@@ -233,6 +233,7 @@ file = rule*:xs space !. -> {
         "struct Variable* variable = variables->pre_first->next;\n"
         "while (variable) {\n" >
             "if (compare_buffers(variable->name, name_to_look_for)) {\n" >
+                "fprintf(stderr, \"debug: found action %p\\n\", variable->action);\n"
                 "return variable->action;\n"
             < "} else {\n" >
                 "variable = variable->next;\n"
@@ -400,6 +401,7 @@ matchExprRepeat =
             < "}\n"
             "append_named_action(star_variables, NULL, _);\n"
         < "}\n"
+        "fprintf(stderr, \"debug: creating_star [%d, %d, %p]\\n\", star_start_pos, parse_state->pos, star_variables->pre_first->next);\n"
         "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n"
     }
     | matchExprPrimitive:x -> {

commit 86b81f02b573a6b1fe662207ae42ce690bd9bc84
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 11:20:35 2025 +0100

    Better debug printout

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 8cd798c..995f2ca 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -154,9 +154,11 @@ file = rule*:xs space !. -> {
         "chunks->last = chunk;\n"
         "fprintf(stderr, \"debug: append chunk = %p\\n\", chunk);\n"
         "if (chunk->data) {\n" >
+            "fprintf(stderr, \"  data = \");\n"
             "for (int i=0; i<chunk->data->size; i++) {\n" >
-                "fprintf(stderr, \" data[%d] = '%c'\\n\", i, chunk->data->buffer[i]);\n"
+                "fprintf(stderr, \"%c\", chunk->data->buffer[i]);\n"
             < "}\n"
+            "fprintf(stderr, \"\\n\");\n"
         < "}\n"
     < "}\n"
     "\n"

commit 121b10beef8ee9783b8fc50566a019960d04df96
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 11:05:30 2025 +0100

    Fix bad memory access in chunk->data

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 6729715..8cd798c 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -153,6 +153,11 @@ file = rule*:xs space !. -> {
         "chunks->last->next = chunk;\n"
         "chunks->last = chunk;\n"
         "fprintf(stderr, \"debug: append chunk = %p\\n\", chunk);\n"
+        "if (chunk->data) {\n" >
+            "for (int i=0; i<chunk->data->size; i++) {\n" >
+                "fprintf(stderr, \" data[%d] = '%c'\\n\", i, chunk->data->buffer[i]);\n"
+            < "}\n"
+        < "}\n"
     < "}\n"
     "\n"
     "struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {\n" >
@@ -254,16 +259,19 @@ file = rule*:xs space !. -> {
             "struct Chunk* chunk = chunks->pre_first->next;\n"
             "while (chunk) {\n" >
                 "*indent += chunk->indentation_delta;\n"
-                "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n"
-                "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n"
-                "for (int i=0; i<chunk->data->size; i++) {\n" >
-                    "if (*last_char == '\\n') {\n" >
-                        "for (int j=0; j<*indent; j++) {\n" >
-                            "printf(\"    \");\n"
+                "if (chunk->data) {\n" >
+                    "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n"
+                    "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n"
+                    "for (int i=0; i<chunk->data->size; i++) {\n" >
+                        "if (*last_char == '\\n') {\n" >
+                            "for (int j=0; j<*indent; j++) {\n" >
+                                "printf(\"    \");\n"
+                            < "}\n"
                         < "}\n"
+                        "*last_char = chunk->data->buffer[i];\n"
+                        "putchar(*last_char);\n"
+                        "fflush(stdout);\n"
                     < "}\n"
-                    "*last_char = chunk->data->buffer[i];\n"
-                    "putchar(*last_char);\n"
                 < "}\n"
                 "render_chunks(chunk->chunks, last_char, indent);\n"
                 "chunk = chunk->next;\n"

2025-11-01 10:49 Rickard pushed to rlmeta2

commit 79c0ad587edf9d784b4984f49cd6b4d0a27216b7
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:48:58 2025 +0100

    Fix if in run_action that had been swapped

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 8c9faab..6729715 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -181,6 +181,8 @@ file = rule*:xs space !. -> {
     "\n"
     "void run_action(struct Action* action, struct Runtime* runtime) {\n" >
         "if (action->function) {\n" >
+            "action->function(runtime, action->variables);\n"
+        < "} else {\n" >
             "if (action->variables) {\n" >
                 "fprintf(stderr, \"debug_run_action variables\\n\");\n"
                 "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n"
@@ -192,9 +194,6 @@ file = rule*:xs space !. -> {
                     "variable = variable->next;\n"
                 < "}\n"
             < "}\n"
-        < "} else {\n" >
-            "fprintf(stderr, \"debug_run_action custom\\n\");\n"
-            "action->function(runtime, action->variables);\n"
         < "}\n"
     < "}\n"
     "\n"

commit 116ed385cc8985f0dc1f1684ee4d2f7f3971826f
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:43:16 2025 +0100

    More debug

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 1e66e85..8c9faab 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -182,8 +182,10 @@ file = rule*:xs space !. -> {
     "void run_action(struct Action* action, struct Runtime* runtime) {\n" >
         "if (action->function) {\n" >
             "if (action->variables) {\n" >
+                "fprintf(stderr, \"debug_run_action variables\\n\");\n"
                 "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n"
             < "} else {\n" >
+                "fprintf(stderr, \"debug_run_action else\\n\");\n"
                 "struct Variable* variable = action->variables->pre_first->next;\n"
                 "while (variable) {\n" >
                     "run_action(variable->action, runtime);\n"
@@ -191,6 +193,7 @@ file = rule*:xs space !. -> {
                 < "}\n"
             < "}\n"
         < "} else {\n" >
+            "fprintf(stderr, \"debug_run_action custom\\n\");\n"
             "action->function(runtime, action->variables);\n"
         < "}\n"
     < "}\n"

commit d17ba9d050d9ee0b167f66e3b993a086f2e893bf
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:38:33 2025 +0100

    Fix possibly bad initialization

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 67b6680..1e66e85 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -103,6 +103,7 @@ file = rule*:xs space !. -> {
     "struct Chunks* create_chunks() {\n" >
         "struct Chunks* chunks = allocate(sizeof(struct Chunks));\n"
         "chunks->pre_first = allocate(sizeof(struct Chunk));\n"
+        "chunks->pre_first->next = NULL;\n"
         "chunks->last = chunks->pre_first;\n"
         "return chunks;\n"
     < "}\n"
@@ -110,6 +111,7 @@ file = rule*:xs space !. -> {
     "struct Placeholders* create_placeholders() {\n" >
         "struct Placeholders* placeholders = allocate(sizeof(struct Placeholders));\n"
         "placeholders->pre_first = allocate(sizeof(struct Placeholder));\n"
+        "placeholders->pre_first->next = NULL;\n"
         "placeholders->last = placeholders->pre_first;\n"
         "return placeholders;\n"
     < "}\n"
@@ -137,6 +139,7 @@ file = rule*:xs space !. -> {
     "struct Variables* create_variables() {\n" >
         "struct Variables* variables = allocate(sizeof(struct Variables));\n"
         "variables->pre_first = allocate(sizeof(struct Variable));\n"
+        "variables->pre_first->next = NULL;\n"
         "variables->last = variables->pre_first;\n"
         "return variables;\n"
     < "}\n"

commit fad8679a5a55a7a0c1dba2adaffd734006033cf3
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:35:13 2025 +0100

    More debug

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index f6a1e58..67b6680 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -149,6 +149,7 @@ file = rule*:xs space !. -> {
         "chunk->indentation_delta = indentation_delta;\n"
         "chunks->last->next = chunk;\n"
         "chunks->last = chunk;\n"
+        "fprintf(stderr, \"debug: append chunk = %p\\n\", chunk);\n"
     < "}\n"
     "\n"
     "struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {\n" >
@@ -422,6 +423,7 @@ action =
                 "struct Chunks* chunks;\n"
                 "struct Chunks* last_chunks;\n"
                 "struct Action* action;\n"
+                "fprintf(stderr, \"debug: running action_" W[0] "\\n\");\n"
                 xs
             < "}\n"
             "\n"

commit 3240868b60316330fe81cd3aedf9b5617cb4e79d
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:19:22 2025 +0100

    Better debug printout

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 79cc700..f6a1e58 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -4,6 +4,7 @@ file = rule*:xs space !. -> {
     "#include <stdio.h>\n"
     "#include <string.h>\n"
     "#include <stdlib.h>\n"
+    "#include <stdint.h>\n"
     "\n"
     "struct Variables;\n"
     "\n"
@@ -95,7 +96,7 @@ file = rule*:xs space !. -> {
             "parse_state->input_buffer->size++;\n"
         < "}\n"
         "*pos = '\\0';\n"
-        "fprintf(stderr, \"debug: stdin data memory = %d\\n\", parse_state->input_buffer->buffer);\n"
+        "fprintf(stderr, \"debug: stdin data memory = %p\\n\", parse_state->input_buffer->buffer);\n"
         "return parse_state;\n"
     < "}\n"
     "\n"
@@ -247,7 +248,8 @@ file = rule*:xs space !. -> {
             "struct Chunk* chunk = chunks->pre_first->next;\n"
             "while (chunk) {\n" >
                 "*indent += chunk->indentation_delta;\n"
-                "fprintf(stderr, \"debug: chunk data memory = %d\\n\", chunk->data->buffer);\n"
+                "fprintf(stderr, \"debug: chunk data memory = %p\\n\", chunk->data->buffer);\n"
+                "fprintf(stderr, \"debug: arena offset      = %u\\n\", ((uintptr_t)chunk->data->buffer)-((uintptr_t)arena));\n"
                 "for (int i=0; i<chunk->data->size; i++) {\n" >
                     "if (*last_char == '\\n') {\n" >
                         "for (int j=0; j<*indent; j++) {\n" >
@@ -292,6 +294,9 @@ file = rule*:xs space !. -> {
             "run_action(placeholder->action, runtime);\n"
             "placeholder = placeholder->next;\n"
         < "}\n"
+        "fprintf(stderr, \"debug: arena memory = %p\\n\", arena);\n"
+        "fprintf(stderr, \"debug: arena limit  = %u\\n\", arena_limit);\n"
+        "fprintf(stderr, \"debug: arena used   = %u\\n\", arena_pos);\n"
         "render_chunks(runtime->main_chunks, &last_char, &indent);\n"
     < "}\n"
 };

commit a2f7ff858701e8ebe230186944a2ab2c7f50c3e0
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:09:09 2025 +0100

    Better OOM bounds check

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 890279c..79cc700 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -75,7 +75,7 @@ file = rule*:xs space !. -> {
     "void* allocate(size_t size) {\n" >
         "void* pointer = arena + arena_pos;\n"
         "arena_pos += size;\n"
-        "if (arena_pos > arena_limit) {\n" >
+        "if (arena_pos >= arena_limit) {\n" >
             "fprintf(stderr, \"ERROR: out of memory\");\n"
             "exit(1);\n"
         < "}\n"

commit 7981687021f0905aa0463125c600952d5e8d6d30
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:07:33 2025 +0100

    More debug print

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 2eecd7e..890279c 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -95,6 +95,7 @@ file = rule*:xs space !. -> {
             "parse_state->input_buffer->size++;\n"
         < "}\n"
         "*pos = '\\0';\n"
+        "fprintf(stderr, \"debug: stdin data memory = %d\\n\", parse_state->input_buffer->buffer);\n"
         "return parse_state;\n"
     < "}\n"
     "\n"
@@ -246,6 +247,7 @@ file = rule*:xs space !. -> {
             "struct Chunk* chunk = chunks->pre_first->next;\n"
             "while (chunk) {\n" >
                 "*indent += chunk->indentation_delta;\n"
+                "fprintf(stderr, \"debug: chunk data memory = %d\\n\", chunk->data->buffer);\n"
                 "for (int i=0; i<chunk->data->size; i++) {\n" >
                     "if (*last_char == '\\n') {\n" >
                         "for (int j=0; j<*indent; j++) {\n" >

commit fd42fa230f5c60c668259eb426a377cd6dd585ce
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 10:03:25 2025 +0100

    Fix bad index increment

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 4f5c077..2eecd7e 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -248,7 +248,7 @@ file = rule*:xs space !. -> {
                 "*indent += chunk->indentation_delta;\n"
                 "for (int i=0; i<chunk->data->size; i++) {\n" >
                     "if (*last_char == '\\n') {\n" >
-                        "for (int j=0; j<*indent; i++) {\n" >
+                        "for (int j=0; j<*indent; j++) {\n" >
                             "printf(\"    \");\n"
                         < "}\n"
                     < "}\n"

commit cf3c1cd90a7d36a8b5aea5fb504b91efa5404982
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:46:08 2025 +0100

    Debug print to stderr

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 2762b07..4f5c077 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -76,7 +76,7 @@ file = rule*:xs space !. -> {
         "void* pointer = arena + arena_pos;\n"
         "arena_pos += size;\n"
         "if (arena_pos > arena_limit) {\n" >
-            "printf(\"ERROR: out of memory\");\n"
+            "fprintf(stderr, \"ERROR: out of memory\");\n"
             "exit(1);\n"
         < "}\n"
         "return pointer;\n"
@@ -128,7 +128,7 @@ file = rule*:xs space !. -> {
         "action->start = start;\n"
         "action->end = end;\n"
         "action->len = end-start;\n"
-        "printf(\"debug: action [start=%d] [end=%d]\\n\", action->start, action->end);\n"
+        "fprintf(stderr, \"debug: action [start=%d] [end=%d]\\n\", action->start, action->end);\n"
         "return action;\n"
     < "}\n"
     "\n"
@@ -223,7 +223,7 @@ file = rule*:xs space !. -> {
                 "variable = variable->next;\n"
             < "}\n"
         < "}\n"
-        "printf(\"ERROR: variable not found\");\n"
+        "fprintf(stderr, \"ERROR: variable not found\");\n"
         "exit(1);\n"
     < "}\n"
     "\n"
@@ -241,7 +241,7 @@ file = rule*:xs space !. -> {
     < "}\n"
     "\n"
     "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n" >
-        "printf(\"debug: render chunks\\n\");\n"
+        "fprintf(stderr, \"debug: render chunks\\n\");\n"
         "if (chunks) {\n" >
             "struct Chunk* chunk = chunks->pre_first->next;\n"
             "while (chunk) {\n" >
@@ -274,13 +274,13 @@ file = rule*:xs space !. -> {
         "struct ParseState* parse_state = create_parse_state_from_stdin();\n"
         "char last_char = '\\n';\n"
         "int indent = 0;\n"
-        "printf(parse_state->input_buffer->buffer);\n"
+        "fprintf(stderr, parse_state->input_buffer->buffer);\n"
 
         "struct Runtime* runtime = create_runtime();\n"
         "struct Action* action = rule_main(parse_state);\n"
         "struct Placeholder* placeholder;\n"
         "if (action == NULL) {\n" >
-            "printf(\"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n"
+            "fprintf(stderr, \"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n"
             "exit(1);\n"
         < "}\n"
         "run_action(action, runtime);\n"
@@ -308,9 +308,9 @@ rule = space name:x space '=' space ors:y space ';' -> {
         "struct Variables* star_variables;\n"
         "struct Action* _;\n"
         "struct Buffer* data;\n"
-        "printf(\"debug: rule " x " [pos=%d]\\n\", parse_state->pos);\n"
+        "fprintf(stderr, \"debug: rule " x " [pos=%d]\\n\", parse_state->pos);\n"
         y
-        "printf(\"debug: rule fail " x " [pos=%d]\\n\", parse_state->pos);\n"
+        "fprintf(stderr, \"debug: rule fail " x " [pos=%d]\\n\", parse_state->pos);\n"
         "return NULL;\n"
     < "}\n"
     "\n"
diff --git a/08_translate_to_c/test.sh b/08_translate_to_c/test.sh
index a772f91..fd236db 100755
--- a/08_translate_to_c/test.sh
+++ b/08_translate_to_c/test.sh
@@ -10,7 +10,8 @@ gcc -o experiments experiments.c && ./experiments
 echo "Compiling rlmeta2_meta.py"
 python rlmeta2.py <rlmeta2.rlmeta2 >rlmeta2_meta.py
 python rlmeta2_meta.py <rlmeta2.rlmeta2 >rlmeta2_meta.c
-gcc -Wfatal-errors -o rlmeta2_meta rlmeta2_meta.c && ./rlmeta2_meta <rlmeta2.rlmeta2
+gcc -Wfatal-errors -o rlmeta2_meta rlmeta2_meta.c
+./rlmeta2_meta <rlmeta2.rlmeta2 >rlmeta2_meta_meta.c
 
 #echo "Is metacompiler? Diff rlmeta2_meta.py"
 #diff rlmeta2.py rlmeta2_meta.py

commit c93e90b92c25ade3bf4270e36b0990cadbb384af
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:41:00 2025 +0100

    Finish implementation of render_chunks

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 8944614..2762b07 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -246,13 +246,15 @@ file = rule*:xs space !. -> {
             "struct Chunk* chunk = chunks->pre_first->next;\n"
             "while (chunk) {\n" >
                 "*indent += chunk->indentation_delta;\n"
-                "//for char in chunk.data:\n" >
-                    "//if last_char == b'\\n':\n" >
-                        "//sys.stdout.buffer.write(b'    '*indent)\n"
-                    < "//}\n"
-                    "//last_char = char.to_bytes()\n"
-                    "//sys.stdout.buffer.write(last_char)\n"
-                < "//}\n"
+                "for (int i=0; i<chunk->data->size; i++) {\n" >
+                    "if (*last_char == '\\n') {\n" >
+                        "for (int j=0; j<*indent; i++) {\n" >
+                            "printf(\"    \");\n"
+                        < "}\n"
+                    < "}\n"
+                    "*last_char = chunk->data->buffer[i];\n"
+                    "putchar(*last_char);\n"
+                < "}\n"
                 "render_chunks(chunk->chunks, last_char, indent);\n"
                 "chunk = chunk->next;\n"
             < "}\n"

commit 6ac1232a4f237c330f9d6fa918bcabedd178d1b4
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:35:38 2025 +0100

    Fix off by one error

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 83f916d..8944614 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -128,6 +128,7 @@ file = rule*:xs space !. -> {
         "action->start = start;\n"
         "action->end = end;\n"
         "action->len = end-start;\n"
+        "printf(\"debug: action [start=%d] [end=%d]\\n\", action->start, action->end);\n"
         "return action;\n"
     < "}\n"
     "\n"
@@ -240,6 +241,7 @@ file = rule*:xs space !. -> {
     < "}\n"
     "\n"
     "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n" >
+        "printf(\"debug: render chunks\\n\");\n"
         "if (chunks) {\n" >
             "struct Chunk* chunk = chunks->pre_first->next;\n"
             "while (chunk) {\n" >
@@ -276,7 +278,7 @@ file = rule*:xs space !. -> {
         "struct Action* action = rule_main(parse_state);\n"
         "struct Placeholder* placeholder;\n"
         "if (action == NULL) {\n" >
-            "printf(\"ERROR: parse error\");\n"
+            "printf(\"ERROR: parse error [pos=%d] [size=%d]\", parse_state->pos, parse_state->input_buffer->size);\n"
             "exit(1);\n"
         < "}\n"
         "run_action(action, runtime);\n"
@@ -385,7 +387,7 @@ matchExprPrimitive =
         "_ = rule_" x "(parse_state);\n"
     }
     | '.'          -> {
-        "if (parse_state->pos <= parse_state->input_buffer->size) {\n" >
+        "if (parse_state->pos < parse_state->input_buffer->size) {\n" >
             "parse_state->pos += 1;\n"
             "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);\n"
         < "} else {\n" >

commit c21b1c3e9b3037dbe3b4e281926b3b91fe2c21f5
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:29:12 2025 +0100

    More debug printout

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index c08736d..83f916d 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -306,6 +306,8 @@ rule = space name:x space '=' space ors:y space ';' -> {
         "struct Buffer* data;\n"
         "printf(\"debug: rule " x " [pos=%d]\\n\", parse_state->pos);\n"
         y
+        "printf(\"debug: rule fail " x " [pos=%d]\\n\", parse_state->pos);\n"
+        "return NULL;\n"
     < "}\n"
     "\n"
 };
@@ -314,7 +316,6 @@ ors = maybeorbar orcase:x restorcase*:xs -> {
     "or_backtrack_pos = parse_state->pos;\n"
     x
     xs
-    "return NULL;\n"
 };
 
 restorcase = orbar orcase:x -> { x };

commit 04ef74b4025f0ae49bfaa08cab81048f2e1bb972
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:27:58 2025 +0100

    Experiment with printf + %s

diff --git a/08_translate_to_c/experiments.c b/08_translate_to_c/experiments.c
index aacefe2..64ea718 100644
--- a/08_translate_to_c/experiments.c
+++ b/08_translate_to_c/experiments.c
@@ -28,4 +28,6 @@ int main(void) {
     printf("Sizeof foo       = %d\n", sizeof(foo));
     printf("Sizeof bar       = %d\n", sizeof(bar));
     printf("äpple\n", sizeof(Bar));
+    printf("string foo = %s\n", foo);
+    printf("string bar = %s\n", bar);
 }

commit 899628bae532278af98cd236d722df5dd634facb
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:14:09 2025 +0100

    Fix char string comparison (and allocate more memory needed)

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 79ba84b..c08736d 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -264,7 +264,7 @@ file = rule*:xs space !. -> {
     <placeholders
     xs
     "int main(void) {\n" >
-        "arena_limit = 2<<20;\n"
+        "arena_limit = 2<<30;\n"
         "arena_pos = 0;\n"
         "arena = malloc(arena_limit);\n"
         "struct ParseState* parse_state = create_parse_state_from_stdin();\n"
@@ -393,7 +393,7 @@ matchExprPrimitive =
     }
     | charstring:x -> {
         "data = " x ";\n"
-        "if (0) { // TODO match: parse_state->input_buffer[parse_state->pos:parse_state->pos+len(data)] == data) {\n" >
+        "if (parse_state->input_buffer->size-parse_state->pos >= data->size && compare_buffers(data, create_slice(parse_state->input_buffer, parse_state->pos, parse_state->pos+data->size))) {\n" >
             "parse_state->pos += data->size;\n"
             "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);\n"
         < "} else {\n" >

commit 2410b5640d57e83b10910796036bdf8a35cdd94c
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:08:07 2025 +0100

    Correct size for buffer_from_cstring

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 1d3ca97..79ba84b 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -518,7 +518,7 @@ string = '"' stringinner*:xs '"' -> {
     >symbols {
         "static char symbol_" W[2] "[] = \"" xs "\";\n"
     }
-    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
+    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] ")-1)"
 };
 
 dotname = nameAsSymbol:x nextname*:xs -> {
@@ -548,7 +548,7 @@ charstring = quote innercharstring*:xs quote -> {
     >symbols {
         "static char symbol_" W[2] "[] = \"" xs "\";\n"
     }
-    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
+    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] ")-1)"
 };
 
 quote = '\'';
@@ -564,7 +564,7 @@ nameAsSymbol = name:x -> {
     >symbols {
         "static char symbol_" W[2] "[] = \"" x "\";\n"
     }
-    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
+    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] ")-1)"
 };
 
 name = char char*;

commit 0c0df65c260ef35ecbb576ae0fc249fdb76b7cb3
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:06:32 2025 +0100

    More debug

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index d1f3636..1d3ca97 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -304,7 +304,7 @@ rule = space name:x space '=' space ors:y space ';' -> {
         "struct Variables* star_variables;\n"
         "struct Action* _;\n"
         "struct Buffer* data;\n"
-        "printf(\"debug: rule " x "\\n\");\n"
+        "printf(\"debug: rule " x " [pos=%d]\\n\", parse_state->pos);\n"
         y
     < "}\n"
     "\n"

commit 2743137d3a3410db37509f20dd34161bf5c87eb3
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:03:52 2025 +0100

    Add debug printouts to see how far we get in parsing

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index c379f56..d1f3636 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -304,6 +304,7 @@ rule = space name:x space '=' space ors:y space ';' -> {
         "struct Variables* star_variables;\n"
         "struct Action* _;\n"
         "struct Buffer* data;\n"
+        "printf(\"debug: rule " x "\\n\");\n"
         y
     < "}\n"
     "\n"

commit 3f70d2dd2e512ef81e7c05797332624310483c4d
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 09:02:15 2025 +0100

    Render all symbols as strings

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 15f28d7..c379f56 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -354,8 +354,8 @@ matchExpr =
     ;
 
 matchAssign =
-    | ':' cname:x -> { "append_named_action(variables, " x ", _);\n" }
-    |             -> {}
+    | ':' nameAsSymbol:x -> { "append_named_action(variables, " x ", _);\n" }
+    |                    -> {}
     ;
 
 matchExprRepeat =
@@ -421,7 +421,7 @@ action =
     ;
 
 actionexpr =
-    | space 'unseen(' cname:x ') -> {' actionexpr*:ys space '}' -> {
+    | space 'unseen(' nameAsSymbol:x ') -> {' actionexpr*:ys space '}' -> {
         "action = lookup_action(variables, " x ");\n"
         "if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {\n" >
             ys
@@ -442,7 +442,7 @@ actionexpr =
     | space expr:x -> {
         "append_data(runtime->current_chunks, buffer_from_integer(" x "), 0, NULL);\n"
     }
-    | space cname:x -> {
+    | space nameAsSymbol:x -> {
         "run_action(lookup_action(variables, " x "), runtime);\n"
     }
     | space placeholder:x -> {
@@ -520,7 +520,7 @@ string = '"' stringinner*:xs '"' -> {
     "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
 };
 
-dotname = cname:x nextname*:xs -> {
+dotname = nameAsSymbol:x nextname*:xs -> {
     "lookup_action(variables, " x ")" xs
 };
 
@@ -545,7 +545,7 @@ stringend = '"';
 charstring = quote innercharstring*:xs quote -> {
     #inc(W[2] 1)
     >symbols {
-        "static char symbol_" W[2] "[] = {" xs "};\n"
+        "static char symbol_" W[2] "[] = \"" xs "\";\n"
     }
     "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
 };
@@ -553,26 +553,19 @@ charstring = quote innercharstring*:xs quote -> {
 quote = '\'';
 
 innercharstring =
-    | '\\\''     -> { "'.', " }
-    | !quote .:x -> { "'.', " }
+    | '\\\''
+    | '"' -> { "\\\"" }
+    | !quote .
     ;
 
-cname = cchar:x ccharInner*:xs -> {
+nameAsSymbol = name:x -> {
     #inc(W[2] 1)
     >symbols {
-        "static char symbol_" W[2] "[] = {" x xs "};\n"
+        "static char symbol_" W[2] "[] = \"" x "\";\n"
     }
     "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
 };
 
-ccharInner = cchar:x -> {
-    ", " x
-};
-
-cchar = char:x -> {
-    "'" x "'"
-};
-
 name = char char*;
 
 char =

commit df8884197af63c30c41f14cc5e7384ef733da8f6
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 08:55:37 2025 +0100

    Less contrived use of double quotes

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 2395648..15f28d7 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -512,10 +512,10 @@ expr =
     }
     ;
 
-string = '"':x stringinner*:xs '"':y -> {
+string = '"' stringinner*:xs '"' -> {
     #inc(W[2] 1)
     >symbols {
-        "static char symbol_" W[2] "[] = " x xs y ";\n"
+        "static char symbol_" W[2] "[] = \"" xs "\";\n"
     }
     "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
 };

commit d7a8eafea9c3fc4c99b6f6459dbcdc1e8028c765
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 08:54:51 2025 +0100

    Experiment with sizeof string constants

diff --git a/08_translate_to_c/experiments.c b/08_translate_to_c/experiments.c
index fd056f8..aacefe2 100644
--- a/08_translate_to_c/experiments.c
+++ b/08_translate_to_c/experiments.c
@@ -15,6 +15,8 @@ typedef struct {
 } Bar;
 
 int main(void) {
+    char foo[] = "hello";
+    char* bar = "hello";
     printf("Sizeof char      = %d\n", sizeof(char));
     printf("Sizeof short     = %d\n", sizeof(short));
     printf("Sizeof int       = %d\n", sizeof(int));
@@ -23,5 +25,7 @@ int main(void) {
     printf("Sizeof pointer   = %d\n", sizeof(void *));
     printf("Sizeof Foo       = %d\n", sizeof(Foo));
     printf("Sizeof Bar       = %d\n", sizeof(Bar));
+    printf("Sizeof foo       = %d\n", sizeof(foo));
+    printf("Sizeof bar       = %d\n", sizeof(bar));
     printf("äpple\n", sizeof(Bar));
 }

commit d9b3274a9142c26d7b4b31870ef73376706336e6
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 08:52:27 2025 +0100

    Improve printf now that we can output double quote

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 0c6e439..2395648 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -76,8 +76,7 @@ file = rule*:xs space !. -> {
         "void* pointer = arena + arena_pos;\n"
         "arena_pos += size;\n"
         "if (arena_pos > arena_limit) {\n" >
-            "char message[] = {'O', 'O', 'M', '\\n', '\\0'};\n"
-            "printf(message);\n"
+            "printf(\"ERROR: out of memory\");\n"
             "exit(1);\n"
         < "}\n"
         "return pointer;\n"
@@ -223,8 +222,7 @@ file = rule*:xs space !. -> {
                 "variable = variable->next;\n"
             < "}\n"
         < "}\n"
-        "char message[] = {'V', 'N', 'F', '\\n', '\\0'};\n"
-        "printf(message);\n"
+        "printf(\"ERROR: variable not found\");\n"
         "exit(1);\n"
     < "}\n"
     "\n"
@@ -278,8 +276,7 @@ file = rule*:xs space !. -> {
         "struct Action* action = rule_main(parse_state);\n"
         "struct Placeholder* placeholder;\n"
         "if (action == NULL) {\n" >
-            "char message[] = {'P', 'e', 'e', '\\n', '\\0'};\n"
-            "printf(message);\n"
+            "printf(\"ERROR: parse error\");\n"
             "exit(1);\n"
         < "}\n"
         "run_action(action, runtime);\n"

commit bb8a8e3434ae14252046562a8ef98c6fbbb0d512
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 08:50:32 2025 +0100

    Patch rlmeta string improvements from 07

diff --git a/08_translate_to_c/rlmeta2.py b/08_translate_to_c/rlmeta2.py
index d9dcb95..fb13a4a 100644
--- a/08_translate_to_c/rlmeta2.py
+++ b/08_translate_to_c/rlmeta2.py
@@ -736,10 +736,6 @@ def action_36(runtime, variables):
     runtime.current_chunks = last_chunks
     run_action(lookup_action(variables, 'x'), runtime)
 
-def action_37(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"'", 0)
-
 def rule_main(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
@@ -1632,6 +1628,17 @@ def rule_stringinner(parse_state):
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
+    data = b'\\"'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
     nlookahead_pos = parse_state.pos
     _ = rule_stringend(parse_state)
     if _ == ERROR:
@@ -1708,13 +1715,13 @@ def rule_innercharstring(parse_state):
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'\\\''
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] in [b'\\\'', b'\\\\']:
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return create_action(action_37, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index f99af5f..0c6e439 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -538,7 +538,10 @@ wvar = 'W[' .:x ']' -> {
     x
 };
 
-stringinner = !stringend .;
+stringinner =
+    | '\\"'
+    | !stringend .
+    ;
 
 stringend = '"';
 

commit 9e5085c8e9dac2778dca7b89b1d881857916a31c
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 08:49:12 2025 +0100

    Support escaping "

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 7861aca..fb13a4a 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -1628,6 +1628,17 @@ def rule_stringinner(parse_state):
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
+    data = b'\\"'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
     nlookahead_pos = parse_state.pos
     _ = rule_stringend(parse_state)
     if _ == ERROR:
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 6e00529..9cca9d8 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -453,7 +453,10 @@ wvar = 'W[' .:x ']' -> {
     x
 };
 
-stringinner = !stringend .;
+stringinner =
+    | '\\"'
+    | !stringend .
+    ;
 
 stringend = '"';
 

commit 188cefc363f7490c1b48cf0c1259fe1fe75cfafc
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 08:42:25 2025 +0100

    Nicer formatting

diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 0b90ee4..6e00529 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -461,7 +461,10 @@ charstring = quote innercharstring* quote;
 
 quote = '\'';
 
-innercharstring = '\\\'' | !quote .;
+innercharstring =
+    | '\\\''
+    | !quote .
+    ;
 
 name = char char*;
 

commit 638c3d3fca6d178737a51719ae0c517a44ad2e69
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Sat Nov 1 08:32:44 2025 +0100

    Remove unused action

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 71d6dde..7861aca 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -736,10 +736,6 @@ def action_36(runtime, variables):
     runtime.current_chunks = last_chunks
     run_action(lookup_action(variables, 'x'), runtime)
 
-def action_37(runtime, variables):
-    pass
-    append_data(runtime.current_chunks, b"'", 0)
-
 def rule_main(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
@@ -1714,7 +1710,7 @@ def rule_innercharstring(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        return create_action(action_37, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 64c0e64..0b90ee4 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -461,7 +461,7 @@ charstring = quote innercharstring* quote;
 
 quote = '\'';
 
-innercharstring = '\\\'' -> {"'"} | !quote .;
+innercharstring = '\\\'' | !quote .;
 
 name = char char*;
 

2025-10-31 20:37 Rickard pushed to rlmeta2

commit ac8277154ab45ba18b059cea365af4997d9d6c59
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 20:37:33 2025 +0100

    Add experiment

diff --git a/08_translate_to_c/experiments.c b/08_translate_to_c/experiments.c
index c191312..fd056f8 100644
--- a/08_translate_to_c/experiments.c
+++ b/08_translate_to_c/experiments.c
@@ -23,4 +23,5 @@ int main(void) {
     printf("Sizeof pointer   = %d\n", sizeof(void *));
     printf("Sizeof Foo       = %d\n", sizeof(Foo));
     printf("Sizeof Bar       = %d\n", sizeof(Bar));
+    printf("äpple\n", sizeof(Bar));
 }

2025-10-31 20:29 Rickard pushed to rlmeta2

commit adb071b888edd4df96ec5dbb9f032c3da5885de5
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 20:29:48 2025 +0100

    Translate some more (all C code is now generated and compiles)

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 0764470..f99af5f 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -265,29 +265,31 @@ file = rule*:xs space !. -> {
     <actions
     <placeholders
     xs
-    "/*\n"
-    "if __name__ == '__main__':\n" >
-        "runtime = create_runtime()\n"
-        "action = rule_main(parse_state)\n"
-        "if action == NULL:\n" >
-            "sys.exit('Parse error')\n"
-        <
-        "run_action(action, runtime)\n"
-        "placeholder = runtime.placeholders.pre_first.next\n"
-        "while placeholder:\n" >
-            "runtime.current_chunks = placeholder.chunks\n"
-            "run_action(placeholder.action, runtime)\n"
-            "placeholder = placeholder.next\n"
-        <
-        "render_chunks(runtime.main_chunks)\n"
-    <
-    "*" "/" "\n"
     "int main(void) {\n" >
         "arena_limit = 2<<20;\n"
         "arena_pos = 0;\n"
         "arena = malloc(arena_limit);\n"
         "struct ParseState* parse_state = create_parse_state_from_stdin();\n"
+        "char last_char = '\\n';\n"
+        "int indent = 0;\n"
         "printf(parse_state->input_buffer->buffer);\n"
+
+        "struct Runtime* runtime = create_runtime();\n"
+        "struct Action* action = rule_main(parse_state);\n"
+        "struct Placeholder* placeholder;\n"
+        "if (action == NULL) {\n" >
+            "char message[] = {'P', 'e', 'e', '\\n', '\\0'};\n"
+            "printf(message);\n"
+            "exit(1);\n"
+        < "}\n"
+        "run_action(action, runtime);\n"
+        "placeholder = runtime->placeholders->pre_first->next;\n"
+        "while (placeholder) {\n" >
+            "runtime->current_chunks = placeholder->chunks;\n"
+            "run_action(placeholder->action, runtime);\n"
+            "placeholder = placeholder->next;\n"
+        < "}\n"
+        "render_chunks(runtime->main_chunks, &last_char, &indent);\n"
     < "}\n"
 };
 

commit daf9d284262cfa0aad618b5fda701c33ccc484b1
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 20:24:59 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.py b/08_translate_to_c/rlmeta2.py
index 71d6dde..d9dcb95 100644
--- a/08_translate_to_c/rlmeta2.py
+++ b/08_translate_to_c/rlmeta2.py
@@ -1708,7 +1708,7 @@ def rule_innercharstring(parse_state):
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'\\\''
-    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] in [b'\\\'', b'\\\\']:
         parse_state.pos += len(data)
         _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 5d05c0c..0764470 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -71,7 +71,6 @@ file = rule*:xs space !. -> {
     "static char* arena;\n"
     "static unsigned int arena_limit;\n"
     "static unsigned int arena_pos;\n"
-    "static int ERROR = -1;\n"
     "\n"
     "void* allocate(size_t size) {\n" >
         "void* pointer = arena + arena_pos;\n"
@@ -261,15 +260,16 @@ file = rule*:xs space !. -> {
     < "}\n"
     "\n"
     <symbols
+    <definitions
     "\n"
     <actions
-    "/*\n"
     <placeholders
     xs
+    "/*\n"
     "if __name__ == '__main__':\n" >
         "runtime = create_runtime()\n"
         "action = rule_main(parse_state)\n"
-        "if action == ERROR:\n" >
+        "if action == NULL:\n" >
             "sys.exit('Parse error')\n"
         <
         "run_action(action, runtime)\n"
@@ -292,17 +292,29 @@ file = rule*:xs space !. -> {
 };
 
 rule = space name:x space '=' space ors:y space ';' -> {
-    "def rule_" x "(parse_state):\n" >
+    >definitions {
+        "struct Action* rule_" x "(struct ParseState* parse_state);\n"
+    }
+    "struct Action* rule_" x "(struct ParseState* parse_state) {\n" >
+        "unsigned int or_backtrack_pos;\n"
+        "unsigned int action_start_pos;\n"
+        "unsigned int star_start_pos;\n"
+        "unsigned int star_pos;\n"
+        "unsigned int nlookahead_pos;\n"
+        "struct Variables* variables;\n"
+        "struct Variables* star_variables;\n"
+        "struct Action* _;\n"
+        "struct Buffer* data;\n"
         y
-    <
+    < "}\n"
     "\n"
 };
 
 ors = maybeorbar orcase:x restorcase*:xs -> {
-    "or_backtrack_pos = parse_state.pos\n"
+    "or_backtrack_pos = parse_state->pos;\n"
     x
     xs
-    "return ERROR\n"
+    "return NULL;\n"
 };
 
 restorcase = orbar orcase:x -> { x };
@@ -312,56 +324,55 @@ maybeorbar = orbar | -> {};
 orbar = space '|';
 
 orcase = matchAnd:x -> {
-    "parse_state.pos = or_backtrack_pos\n"
-    "action_start_pos = parse_state.pos\n"
-    "variables = create_variables()\n"
+    "parse_state->pos = or_backtrack_pos;\n"
+    "action_start_pos = parse_state->pos;\n"
+    "variables = create_variables();\n"
     x
 };
 
 matchAnd =
     | space matchExpr:x matchAnd:y -> {
         x
-        "if _ != ERROR:\n" >
+        "if (_) {\n" >
             y
-        <
+        < "}\n"
     }
     | action:y -> { y }
     ;
 
 matchExpr =
     | '!' matchExprPrimitive:x -> {
-        "nlookahead_pos = parse_state.pos\n"
+        "nlookahead_pos = parse_state->pos;\n"
         x
-        "if _ == ERROR:\n" >
-            "_ = lambda: None\n"
-        <
-        "else:\n" >
-            "_ = ERROR\n"
-        <
-        "parse_state.pos = nlookahead_pos\n"
+        "if (_ == NULL) {\n" >
+            "_ = create_action(NULL, NULL, parse_state->input_buffer, 0, 0);\n"
+        < "} else {\n" >
+            "_ = NULL;\n"
+        < "}\n"
+        "parse_state->pos = nlookahead_pos;\n"
     }
     | matchExprRepeat:x matchAssign:y -> { x y }
     ;
 
 matchAssign =
-    | ':' name:x -> { "append_named_action(variables, '" x "', _)\n" }
-    |            -> {}
+    | ':' cname:x -> { "append_named_action(variables, " x ", _);\n" }
+    |             -> {}
     ;
 
 matchExprRepeat =
     | matchExprPrimitive:x '*' -> {
-        "star_variables = create_variables()\n"
-        "star_start_pos = parse_state.pos\n"
-        "while True:\n" >
-            "star_pos = parse_state.pos\n"
+        "star_variables = create_variables();\n"
+        "star_start_pos = parse_state->pos;\n"
+        "while (1) {\n" >
+            "star_pos = parse_state->pos;\n"
             x
-            "if _ == ERROR:\n" >
-                "parse_state.pos = star_pos\n"
-                "break\n"
-            <
-            "append_named_action(star_variables, None, _)\n"
-        <
-        "_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
+            "if (_ == NULL) {\n" >
+                "parse_state->pos = star_pos;\n"
+                "break;\n"
+            < "}\n"
+            "append_named_action(star_variables, NULL, _);\n"
+        < "}\n"
+        "_ = create_action(NULL, star_variables, parse_state->input_buffer, star_start_pos, parse_state->pos);\n"
     }
     | matchExprPrimitive:x -> {
         x
@@ -370,26 +381,24 @@ matchExprRepeat =
 
 matchExprPrimitive =
     | name:x       -> {
-        "_ = rule_" x "(parse_state)\n"
+        "_ = rule_" x "(parse_state);\n"
     }
     | '.'          -> {
-        "if parse_state.pos != len(parse_state.input_buffer):\n" >
-            "parse_state.pos += 1\n"
-            "_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n"
-        <
-        "else:\n" >
-            "_ = ERROR\n"
-        <
+        "if (parse_state->pos <= parse_state->input_buffer->size) {\n" >
+            "parse_state->pos += 1;\n"
+            "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-1, parse_state->pos);\n"
+        < "} else {\n" >
+            "_ = NULL;\n"
+        < "}\n"
     }
     | charstring:x -> {
-        "data = " x "\n"
-        "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n" >
-            "parse_state.pos += len(data)\n"
-            "_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n"
-        <
-        "else:\n" >
-            "_ = ERROR\n"
-        <
+        "data = " x ";\n"
+        "if (0) { // TODO match: parse_state->input_buffer[parse_state->pos:parse_state->pos+len(data)] == data) {\n" >
+            "parse_state->pos += data->size;\n"
+            "_ = create_action(NULL, NULL, parse_state->input_buffer, parse_state->pos-data->size, parse_state->pos);\n"
+        < "} else {\n" >
+            "_ = NULL;\n"
+        < "}\n"
     }
     ;
 
@@ -405,10 +414,10 @@ action =
             < "}\n"
             "\n"
         }
-        "return create_action(action_" W[0] ", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+        "return create_action(action_" W[0] ", variables, parse_state->input_buffer, action_start_pos, parse_state->pos);\n"
     }
     | -> {
-        "return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+        "return create_action(NULL, NULL, parse_state->input_buffer, action_start_pos, parse_state->pos);\n"
     }
     ;
 
@@ -440,10 +449,9 @@ actionexpr =
     | space placeholder:x -> {
         #inc(W[1] 1)
         >placeholders {
-            "def placeholder_" W[1] "(runtime, variables):\n" >
-                "pass\n"
+            "void placeholder_" W[1] "(struct Runtime* runtime, struct Variables* variables) {" >
                 x
-            <
+            < "}\n"
             "\n"
         }
         "chunks = create_chunks()\n"
@@ -532,11 +540,20 @@ stringinner = !stringend .;
 
 stringend = '"';
 
-charstring = quote innercharstring* quote;
+charstring = quote innercharstring*:xs quote -> {
+    #inc(W[2] 1)
+    >symbols {
+        "static char symbol_" W[2] "[] = {" xs "};\n"
+    }
+    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
+};
 
 quote = '\'';
 
-innercharstring = '\\\'' -> {"'"} | !quote .;
+innercharstring =
+    | '\\\''     -> { "'.', " }
+    | !quote .:x -> { "'.', " }
+    ;
 
 cname = cchar:x ccharInner*:xs -> {
     #inc(W[2] 1)

commit aa201d7ebac7de7bf6fecd8fcdb8076934510a98
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 19:35:16 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index f60c02a..5d05c0c 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -26,7 +26,7 @@ file = rule*:xs space !. -> {
     < "};\n"
     "\n"
     "struct Action {\n" >
-        "int (*function)(struct Runtime*, struct Variables*);\n"
+        "void (*function)(struct Runtime*, struct Variables*);\n"
         "struct Variables* variables;\n"
         "struct Buffer* input_buffer;\n"
         "unsigned int start;\n"
@@ -122,7 +122,7 @@ file = rule*:xs space !. -> {
         "return runtime;\n"
     < "}\n"
     "\n"
-    "struct Action* create_action(int (*function)(struct Runtime*, struct Variables*), struct Variables* variables, struct Buffer* input_buffer, unsigned int start, unsigned int end) {\n" >
+    "struct Action* create_action(void (*function)(struct Runtime*, struct Variables*), struct Variables* variables, struct Buffer* input_buffer, unsigned int start, unsigned int end) {\n" >
         "struct Action* action = allocate(sizeof(struct Action));\n"
         "action->function = function;\n"
         "action->variables = variables;\n"
@@ -158,6 +158,22 @@ file = rule*:xs space !. -> {
         "return buffer;\n"
     < "}\n"
     "\n"
+    "struct Buffer* buffer_from_cstring(char* data, unsigned int size) {\n" >
+        "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n"
+        "buffer->buffer = data;\n"
+        "buffer->size = size;\n"
+        "return buffer;\n"
+    < "}\n"
+    "\n"
+    "struct Buffer* buffer_from_integer(unsigned int value) {\n" >
+        "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n"
+        "char format_string[] = {'%', 'd'};\n"
+        "buffer->buffer = allocate(20);\n"
+        "sprintf(buffer->buffer, format_string, value);\n"
+        "buffer->size = strlen(buffer->buffer);\n"
+        "return buffer;\n"
+    < "}\n"
+    "\n"
     "void run_action(struct Action* action, struct Runtime* runtime) {\n" >
         "if (action->function) {\n" >
             "if (action->variables) {\n" >
@@ -243,10 +259,11 @@ file = rule*:xs space !. -> {
             < "}\n"
         < "}\n"
     < "}\n"
-    "/*\n"
     "\n"
+    <symbols
     "\n"
     <actions
+    "/*\n"
     <placeholders
     xs
     "if __name__ == '__main__':\n" >
@@ -365,7 +382,7 @@ matchExprPrimitive =
         <
     }
     | charstring:x -> {
-        "data = b" x "\n"
+        "data = " x "\n"
         "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n" >
             "parse_state.pos += len(data)\n"
             "_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n"
@@ -380,10 +397,12 @@ action =
     | space '->' space '{' actionexpr*:xs space '}' -> {
         #inc(W[0] 1)
         >actions {
-            "def action_" W[0] "(runtime, variables):\n" >
-                "pass\n"
+            "void action_" W[0] "(struct Runtime* runtime, struct Variables* variables) {\n" >
+                "struct Chunks* chunks;\n"
+                "struct Chunks* last_chunks;\n"
+                "struct Action* action;\n"
                 xs
-            <
+            < "}\n"
             "\n"
         }
         "return create_action(action_" W[0] ", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
@@ -394,30 +413,29 @@ action =
     ;
 
 actionexpr =
-    | space 'unseen(' name:x ') -> {' actionexpr*:ys space '}' -> {
-        "action = lookup_action(variables, '" x "')\n"
-        "if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):\n" >
-            "pass\n"
+    | space 'unseen(' cname:x ') -> {' actionexpr*:ys space '}' -> {
+        "action = lookup_action(variables, " x ");\n"
+        "if (!seen(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end))) {\n" >
             ys
-        <
+        < "}\n"
     }
     | space '>' chunkName:x space '{' actionexpr*:ys space '}' -> {
-        "last_chunks = runtime.current_chunks\n"
-        "chunks = runtime.named_chunks_" x "\n"
-        "runtime.current_chunks = chunks\n"
+        "last_chunks = runtime->current_chunks;\n"
+        "chunks = runtime->named_chunks_" x ";\n"
+        "runtime->current_chunks = chunks;\n"
         ys
-        "runtime.current_chunks = last_chunks\n"
+        "runtime->current_chunks = last_chunks;\n"
     }
     | space '<' chunkName:x -> {
-        "chunks = create_chunks()\n"
-        "runtime.named_chunks_" x " = chunks\n"
-        "append_data(runtime.current_chunks, b'', 0, chunks)\n"
+        "chunks = create_chunks();\n"
+        "runtime->named_chunks_" x " = chunks;\n"
+        "append_data(runtime->current_chunks, NULL, 0, chunks);\n"
     }
     | space expr:x -> {
-        "append_data(runtime.current_chunks, str(" x ").encode('ascii'), 0)\n"
+        "append_data(runtime->current_chunks, buffer_from_integer(" x "), 0, NULL);\n"
     }
-    | space name:x -> {
-        "run_action(lookup_action(variables, '" x "'), runtime)\n"
+    | space cname:x -> {
+        "run_action(lookup_action(variables, " x "), runtime);\n"
     }
     | space placeholder:x -> {
         #inc(W[1] 1)
@@ -429,19 +447,19 @@ actionexpr =
             "\n"
         }
         "chunks = create_chunks()\n"
-        "append_placeholder(runtime.placeholders, chunks, create_action(placeholder_" W[1] ", variables, '', 0, 0))\n"
-        "append_data(runtime.current_chunks, b'', 0, chunks)\n"
+        "append_placeholder(runtime->placeholders, chunks, create_action(placeholder_" W[1] ", variables, '', 0, 0))\n"
+        "append_data(runtime->current_chunks, NULL, 0, chunks);\n"
     }
     | space string:x -> {
-        "append_data(runtime.current_chunks, b" x ", 0)\n"
+        "append_data(runtime->current_chunks, " x ", 0, NULL);\n"
     }
     | space '#' name:x '(' wvar:y ' ' actionPrimitiveExpression:z ')' -> {
-        "runtime.W_" y " = " x "(runtime.W_" y " or 0, " z ")\n"
+        "runtime->W_" y " = " x "(runtime->W_" y " ? runtime->W_" y " : 0, " z ");\n"
     }
     | space '>' actionexpr*:xs space '<' -> {
-        "append_data(runtime.current_chunks, b'', 1)\n"
+        "append_data(runtime->current_chunks, NULL, 1, NULL);\n"
         xs
-        "append_data(runtime.current_chunks, b'', -1)\n"
+        "append_data(runtime->current_chunks, NULL, -1, NULL);\n"
     }
     ;
 
@@ -474,23 +492,29 @@ digit =
 
 placeholder
     = '{' space string:x '*' expr:y space '}' -> {
-        "append_data(runtime.current_chunks, b" x "*" y ", 0)\n"
+        "append_data(runtime->current_chunks, " x "*" y ", 0, NULL);\n"
     }
     ;
 
 expr =
     | wvar:x -> {
-        "(runtime.W_" x " or 0)"
+        "(runtime->W_" x " ? runtime->W_" x " : 0)"
     }
     | '(' wvar:x '-' dotname:y ')' -> {
-        "((runtime.W_" x " or 0)-"  y ")"
+        "((runtime->W_" x " ? runtime->W_" x " : 0)-"  y ")"
     }
     ;
 
-string = '"' stringinner* '"';
+string = '"':x stringinner*:xs '"':y -> {
+    #inc(W[2] 1)
+    >symbols {
+        "static char symbol_" W[2] "[] = " x xs y ";\n"
+    }
+    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
+};
 
-dotname = name:x nextname*:xs -> {
-    "lookup_action(variables, '" x "')" xs
+dotname = cname:x nextname*:xs -> {
+    "lookup_action(variables, " x ")" xs
 };
 
 nextname = '.' name;
@@ -514,6 +538,22 @@ quote = '\'';
 
 innercharstring = '\\\'' -> {"'"} | !quote .;
 
+cname = cchar:x ccharInner*:xs -> {
+    #inc(W[2] 1)
+    >symbols {
+        "static char symbol_" W[2] "[] = {" x xs "};\n"
+    }
+    "buffer_from_cstring(symbol_" W[2] ", sizeof(symbol_" W[2] "))"
+};
+
+ccharInner = cchar:x -> {
+    ", " x
+};
+
+cchar = char:x -> {
+    "'" x "'"
+};
+
 name = char char*;
 
 char =
diff --git a/08_translate_to_c/test.sh b/08_translate_to_c/test.sh
index 039bb0c..a772f91 100755
--- a/08_translate_to_c/test.sh
+++ b/08_translate_to_c/test.sh
@@ -10,7 +10,7 @@ gcc -o experiments experiments.c && ./experiments
 echo "Compiling rlmeta2_meta.py"
 python rlmeta2.py <rlmeta2.rlmeta2 >rlmeta2_meta.py
 python rlmeta2_meta.py <rlmeta2.rlmeta2 >rlmeta2_meta.c
-gcc -o rlmeta2_meta rlmeta2_meta.c && ./rlmeta2_meta <rlmeta2.rlmeta2
+gcc -Wfatal-errors -o rlmeta2_meta rlmeta2_meta.c && ./rlmeta2_meta <rlmeta2.rlmeta2
 
 #echo "Is metacompiler? Diff rlmeta2_meta.py"
 #diff rlmeta2.py rlmeta2_meta.py

commit bbfe292a72aed73ccbedced2488b808ea723f3fc
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:46:13 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 0847091..f60c02a 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -71,6 +71,7 @@ file = rule*:xs space !. -> {
     "static char* arena;\n"
     "static unsigned int arena_limit;\n"
     "static unsigned int arena_pos;\n"
+    "static int ERROR = -1;\n"
     "\n"
     "void* allocate(size_t size) {\n" >
         "void* pointer = arena + arena_pos;\n"
@@ -244,7 +245,6 @@ file = rule*:xs space !. -> {
     < "}\n"
     "/*\n"
     "\n"
-    "ERROR = -1\n"
     "\n"
     <actions
     <placeholders

commit edd873612476a65eca938e7aa4e4008d2b1fe410
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:45:49 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 798ca7f..0847091 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -224,26 +224,25 @@ file = rule*:xs space !. -> {
     "unsigned int inc(unsigned int value, unsigned int amount) {\n" >
         "return value + amount;\n"
     < "}\n"
-    "/*\n"
     "\n"
-    "def render_chunks(chunks, last_char=b'\\n', indent=0):\n" >
-        "if chunks:\n" >
-            "chunk = chunks.pre_first.next\n"
-            "while chunk:\n" >
-                "indent += chunk.indentation_delta\n"
-                "for char in chunk.data:\n" >
-                    "if last_char == b'\\n':\n" >
-                        "sys.stdout.buffer.write(b'    '*indent)\n"
-                    <
-                    "last_char = char.to_bytes()\n"
-                    "sys.stdout.buffer.write(last_char)\n"
-                <
-                "last_char, indent = render_chunks(chunk.chunks, last_char, indent)\n"
-                "chunk = chunk.next\n"
-            <
-        <
-        "return last_char, indent\n"
-    <
+    "void render_chunks(struct Chunks* chunks, char* last_char, int* indent) {\n" >
+        "if (chunks) {\n" >
+            "struct Chunk* chunk = chunks->pre_first->next;\n"
+            "while (chunk) {\n" >
+                "*indent += chunk->indentation_delta;\n"
+                "//for char in chunk.data:\n" >
+                    "//if last_char == b'\\n':\n" >
+                        "//sys.stdout.buffer.write(b'    '*indent)\n"
+                    < "//}\n"
+                    "//last_char = char.to_bytes()\n"
+                    "//sys.stdout.buffer.write(last_char)\n"
+                < "//}\n"
+                "render_chunks(chunk->chunks, last_char, indent);\n"
+                "chunk = chunk->next;\n"
+            < "}\n"
+        < "}\n"
+    < "}\n"
+    "/*\n"
     "\n"
     "ERROR = -1\n"
     "\n"

commit df253049e9f29c6bedc97b8a364c2a5096f813a7
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:40:44 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index a7d9d1d..798ca7f 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -220,11 +220,11 @@ file = rule*:xs space !. -> {
         "placeholders->last->next = next_placeholder;\n"
         "placeholders->last = next_placeholder;\n"
     < "}\n"
-    "/*\n"
     "\n"
-    "def inc(value, amount):\n" >
-        "return value + amount\n"
-    <
+    "unsigned int inc(unsigned int value, unsigned int amount) {\n" >
+        "return value + amount;\n"
+    < "}\n"
+    "/*\n"
     "\n"
     "def render_chunks(chunks, last_char=b'\\n', indent=0):\n" >
         "if chunks:\n" >

commit 5f3c8d1caef541ee3da84e3bb5c929ba524381df
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:39:53 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index c50bcad..a7d9d1d 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -65,7 +65,7 @@ file = rule*:xs space !. -> {
     "struct Placeholder {\n" >
         "struct Placeholder* next;\n"
         "struct Chunks* chunks;\n"
-        "int (*action)(struct Runtime*, struct Variables*);\n"
+        "struct Action* action;\n"
     < "};\n"
     "\n"
     "static char* arena;\n"
@@ -211,16 +211,16 @@ file = rule*:xs space !. -> {
         "printf(message);\n"
         "exit(1);\n"
     < "}\n"
-    "/*\n"
     "\n"
-    "def append_placeholder(placeholders, chunks, action):\n" >
-        "next_variable = Placeholder()\n"
-        "next_variable.next = None\n"
-        "next_variable.chunks = chunks\n"
-        "next_variable.action = action\n"
-        "placeholders.last.next = next_variable\n"
-        "placeholders.last = next_variable\n"
-    <
+    "void append_placeholder(struct Placeholders* placeholders, struct Chunks* chunks, struct Action* action) {\n" >
+        "struct Placeholder* next_placeholder = allocate(sizeof(struct Placeholder));\n"
+        "next_placeholder->next = NULL;\n"
+        "next_placeholder->chunks = chunks;\n"
+        "next_placeholder->action = action;\n"
+        "placeholders->last->next = next_placeholder;\n"
+        "placeholders->last = next_placeholder;\n"
+    < "}\n"
+    "/*\n"
     "\n"
     "def inc(value, amount):\n" >
         "return value + amount\n"

commit 64618d848b25139b07571eeb7c11156ba70f95e3
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:37:12 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 98ffd8e..c50bcad 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -197,20 +197,21 @@ file = rule*:xs space !. -> {
         "variables->last->next = next_variable;\n"
         "variables->last = next_variable;\n"
     < "}\n"
-    "/*\n"
     "\n"
-    "def lookup_action(variables, name_to_look_for):\n" >
-        "variable = variables.pre_first.next\n"
-        "while variable:\n" >
-            "if variable.name == name_to_look_for:\n" >
-                "return variable.action\n"
-            <
-            "else:\n" >
-                "variable = variable.next\n"
-            <
-        <
-        "raise ValueError(f'variable {name_to_look_for} not found')\n"
-    <
+    "struct Action* lookup_action(struct Variables* variables, struct Buffer* name_to_look_for) {\n" >
+        "struct Variable* variable = variables->pre_first->next;\n"
+        "while (variable) {\n" >
+            "if (compare_buffers(variable->name, name_to_look_for)) {\n" >
+                "return variable->action;\n"
+            < "} else {\n" >
+                "variable = variable->next;\n"
+            < "}\n"
+        < "}\n"
+        "char message[] = {'V', 'N', 'F', '\\n', '\\0'};\n"
+        "printf(message);\n"
+        "exit(1);\n"
+    < "}\n"
+    "/*\n"
     "\n"
     "def append_placeholder(placeholders, chunks, action):\n" >
         "next_variable = Placeholder()\n"

commit 0fca5ffc3928df0625410c900509a81b5be108d8
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:34:12 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 1271aec..98ffd8e 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -188,16 +188,16 @@ file = rule*:xs space !. -> {
         < "}\n"
         "return 0;\n"
     < "}\n"
-    "/*\n"
     "\n"
-    "def append_named_action(variables, name, action):\n" >
-        "next_variable = Variable()\n"
-        "next_variable.next = None\n"
-        "next_variable.name = name\n"
-        "next_variable.action = action\n"
-        "variables.last.next = next_variable\n"
-        "variables.last = next_variable\n"
-    <
+    "void append_named_action(struct Variables* variables, struct Buffer* name, struct Action* action) {\n" >
+        "struct Variable* next_variable = allocate(sizeof(struct Variable));\n"
+        "next_variable->next = NULL;\n"
+        "next_variable->name = name;\n"
+        "next_variable->action = action;\n"
+        "variables->last->next = next_variable;\n"
+        "variables->last = next_variable;\n"
+    < "}\n"
+    "/*\n"
     "\n"
     "def lookup_action(variables, name_to_look_for):\n" >
         "variable = variables.pre_first.next\n"

commit 2ca516368b524fd622503650a675a180592df984
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:32:31 2025 +0100

    Translate some more

diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 0abb208..1271aec 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -172,18 +172,23 @@ file = rule*:xs space !. -> {
             "action->function(runtime, action->variables);\n"
         < "}\n"
     < "}\n"
-    "/*\n"
     "\n"
-    "def seen(chunks, data):\n" >
-        "chunk = chunks.pre_first.next\n"
-        "while chunk:\n" >
-            "if chunk.data == data:\n" >
-                "return True\n"
-            <
-            "chunk = chunk.next\n"
-        <
-        "return False\n"
-    <
+    "int compare_buffers(struct Buffer* b1, struct Buffer* b2) {\n" >
+        "if (b1->size != b2->size) return 0;"
+        "return 1;"
+    < "}\n"
+    "\n"
+    "int seen(struct Chunks* chunks, struct Buffer* data) {\n" >
+        "struct Chunk* chunk = chunks->pre_first->next;\n"
+        "while (chunk) {\n" >
+            "if (compare_buffers(chunk->data, data)) {\n" >
+                "return 1;\n"
+            < "}\n"
+            "chunk = chunk->next;\n"
+        < "}\n"
+        "return 0;\n"
+    < "}\n"
+    "/*\n"
     "\n"
     "def append_named_action(variables, name, action):\n" >
         "next_variable = Variable()\n"

commit 7f561830272ee823cc843bd006c730be52d203e4
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 18:27:53 2025 +0100

    Translated some parts to C

diff --git a/08_translate_to_c/.gitignore b/08_translate_to_c/.gitignore
index c0c9a39..21bd4e6 100644
--- a/08_translate_to_c/.gitignore
+++ b/08_translate_to_c/.gitignore
@@ -1,4 +1,5 @@
 table.py
 rlmeta2_meta.py
 rlmeta2_meta.c
+rlmeta2_meta
 experiments
diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
index 64c0e64..0abb208 100644
--- a/08_translate_to_c/rlmeta2.rlmeta2
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -1,139 +1,178 @@
 main = file:x -> { x };
 
 file = rule*:xs space !. -> {
-    "import sys\n"
+    "#include <stdio.h>\n"
+    "#include <string.h>\n"
+    "#include <stdlib.h>\n"
     "\n"
-    "class ParseState:\n" >
-        "input_buffer = None\n"
-        "pos = None\n"
-    <
+    "struct Variables;\n"
+    "\n"
+    "struct Buffer {\n" >
+        "char* buffer;\n"
+        "unsigned int size;\n"
+    < "};\n"
     "\n"
-    "class Runtime:\n" >
-        "main_chunks = None\n"
+    "struct ParseState {\n" >
+        "struct Buffer* input_buffer;\n"
+        "unsigned int pos;\n"
+    < "};\n"
+    "\n"
+    "struct Runtime {\n" >
+        "struct Chunks* main_chunks;\n"
         <namedChunks
-        "current_chunks = None\n"
+        "struct Chunks* current_chunks;\n"
         <namedWs
-        "placeholders = None\n"
-    <
+        "struct Placeholders* placeholders;\n"
+    < "};\n"
     "\n"
-    "class Action:\n" >
-        "function = None\n"
-        "variables = None\n"
-        "input_buffer = None\n"
-        "start = None\n"
-        "end = None\n"
-        "len = None\n"
-    <
+    "struct Action {\n" >
+        "int (*function)(struct Runtime*, struct Variables*);\n"
+        "struct Variables* variables;\n"
+        "struct Buffer* input_buffer;\n"
+        "unsigned int start;\n"
+        "unsigned int end;\n"
+        "unsigned int len;\n"
+    < "};\n"
     "\n"
-    "class Variables:\n" >
-        "pre_first = None\n"
-        "last = None\n"
-    <
+    "struct Variables {\n" >
+        "struct Variable* pre_first;\n"
+        "struct Variable* last;\n"
+    < "};\n"
     "\n"
-    "class Variable:\n" >
-        "next = None\n"
-        "name = None\n"
-        "action = None\n"
-    <
+    "struct Variable {\n" >
+        "struct Variable* next;\n"
+        "struct Buffer* name;\n"
+        "struct Action* action;\n"
+    < "};\n"
     "\n"
-    "class Chunks:\n" >
-        "pre_first = None\n"
-        "last = None\n"
-        "seen = None\n"
-    <
+    "struct Chunks {\n" >
+        "struct Chunk* pre_first;\n"
+        "struct Chunk* last;\n"
+    < "};\n"
     "\n"
-    "class Chunk:\n" >
-        "next = None\n"
-        "data = None\n"
-        "chunks = None\n"
-        "indentation_delta = None\n"
-    <
+    "struct Chunk {\n" >
+        "struct Chunk* next;\n"
+        "struct Buffer* data;\n"
+        "struct Chunks* chunks;\n"
+        "int indentation_delta;\n"
+    < "};\n"
     "\n"
-    "class Placeholders:\n" >
-        "pre_first = None\n"
-        "last = None\n"
-    <
+    "struct Placeholders {\n" >
+        "struct Placeholder* pre_first;\n"
+        "struct Placeholder* last;\n"
+    < "};\n"
     "\n"
-    "class Placeholder:\n" >
-        "next = None\n"
-        "chunks = None\n"
-        "action = None\n"
-    <
+    "struct Placeholder {\n" >
+        "struct Placeholder* next;\n"
+        "struct Chunks* chunks;\n"
+        "int (*action)(struct Runtime*, struct Variables*);\n"
+    < "};\n"
     "\n"
-    "def create_parse_state_from_stdin():\n" >
-        "parse_state = ParseState()\n"
-        "parse_state.input_buffer = sys.stdin.buffer.read()\n"
-        "parse_state.pos = 0\n"
-        "return parse_state\n"
-    <
+    "static char* arena;\n"
+    "static unsigned int arena_limit;\n"
+    "static unsigned int arena_pos;\n"
     "\n"
-    "def create_runtime():\n" >
-        "runtime = Runtime()\n"
-        "runtime.main_chunks = create_chunks()\n"
-        "runtime.current_chunks = runtime.main_chunks\n"
-        "runtime.placeholders = create_placeholders()\n"
-        "return runtime\n"
-    <
+    "void* allocate(size_t size) {\n" >
+        "void* pointer = arena + arena_pos;\n"
+        "arena_pos += size;\n"
+        "if (arena_pos > arena_limit) {\n" >
+            "char message[] = {'O', 'O', 'M', '\\n', '\\0'};\n"
+            "printf(message);\n"
+            "exit(1);\n"
+        < "}\n"
+        "return pointer;\n"
+    < "}\n"
     "\n"
-    "def create_action(function, variables, input_buffer, start, end):\n" >
-        "action = Action()\n"
-        "action.function = function\n"
-        "action.variables = variables\n"
-        "action.input_buffer = input_buffer\n"
-        "action.start = start\n"
-        "action.end = end\n"
-        "action.len = end-start\n"
-        "return action\n"
-    <
+    "struct ParseState* create_parse_state_from_stdin() {\n" >
+        "char* pos;\n"
+        "struct ParseState* parse_state = allocate(sizeof(struct ParseState));\n"
+        "parse_state->input_buffer = allocate(sizeof(struct Buffer));\n"
+        "parse_state->input_buffer->buffer = allocate(1);\n"
+        "parse_state->input_buffer->size = 1;\n"
+        "parse_state->pos = 0;\n"
+        "pos = parse_state->input_buffer->buffer;\n"
+        "while (fgets(pos, 2, stdin)) {\n" >
+            "pos = allocate(1);\n"
+            "parse_state->input_buffer->size++;\n"
+        < "}\n"
+        "*pos = '\\0';\n"
+        "return parse_state;\n"
+    < "}\n"
     "\n"
-    "def create_variables():\n" >
-        "variables = Variables()\n"
-        "variables.pre_first = Variable()\n"
-        "variables.last = variables.pre_first\n"
-        "return variables\n"
-    <
+    "struct Chunks* create_chunks() {\n" >
+        "struct Chunks* chunks = allocate(sizeof(struct Chunks));\n"
+        "chunks->pre_first = allocate(sizeof(struct Chunk));\n"
+        "chunks->last = chunks->pre_first;\n"
+        "return chunks;\n"
+    < "}\n"
     "\n"
-    "def create_chunks():\n" >
-        "chunks = Chunks()\n"
-        "chunks.pre_first = Chunk()\n"
-        "chunks.last = chunks.pre_first\n"
-        "return chunks\n"
-    <
+    "struct Placeholders* create_placeholders() {\n" >
+        "struct Placeholders* placeholders = allocate(sizeof(struct Placeholders));\n"
+        "placeholders->pre_first = allocate(sizeof(struct Placeholder));\n"
+        "placeholders->last = placeholders->pre_first;\n"
+        "return placeholders;\n"
+    < "}\n"
     "\n"
-    "def create_placeholders():\n" >
-        "placeholders = Placeholder()\n"
-        "placeholders.pre_first = Placeholder()\n"
-        "placeholders.last = placeholders.pre_first\n"
-        "return placeholders\n"
-    <
+    "struct Runtime* create_runtime() {\n" >
+        "struct Runtime* runtime = allocate(sizeof(struct Runtime));\n"
+        "runtime->main_chunks = create_chunks();\n"
+        "runtime->current_chunks = runtime->main_chunks;\n"
+        "runtime->placeholders = create_placeholders();\n"
+        "return runtime;\n"
+    < "}\n"
     "\n"
-    "def run_action(action, runtime):\n" >
-        "if action.function is None:\n" >
-            "if action.variables is None:\n" >
-                "append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)\n"
-            <
-            "else:\n" >
-                "variable = action.variables.pre_first.next\n"
-                "while variable:\n" >
-                    "run_action(variable.action, runtime)\n"
-                    "variable = variable.next\n"
-                <
-            <
-        <
-        "else:\n" >
-            "action.function(runtime, action.variables)\n"
-        <
-    <
+    "struct Action* create_action(int (*function)(struct Runtime*, struct Variables*), struct Variables* variables, struct Buffer* input_buffer, unsigned int start, unsigned int end) {\n" >
+        "struct Action* action = allocate(sizeof(struct Action));\n"
+        "action->function = function;\n"
+        "action->variables = variables;\n"
+        "action->input_buffer = input_buffer;\n"
+        "action->start = start;\n"
+        "action->end = end;\n"
+        "action->len = end-start;\n"
+        "return action;\n"
+    < "}\n"
     "\n"
-    "def append_data(chunks, data, indentation_delta, sub_chunks=None):\n" >
-        "chunk = Chunk()\n"
-        "chunk.next = None\n"
-        "chunk.data = data\n"
-        "chunk.chunks = sub_chunks\n"
-        "chunk.indentation_delta = indentation_delta\n"
-        "chunks.last.next = chunk\n"
-        "chunks.last = chunk\n"
-    <
+    "struct Variables* create_variables() {\n" >
+        "struct Variables* variables = allocate(sizeof(struct Variables));\n"
+        "variables->pre_first = allocate(sizeof(struct Variable));\n"
+        "variables->last = variables->pre_first;\n"
+        "return variables;\n"
+    < "}\n"
+    "\n"
+    "void append_data(struct Chunks* chunks, struct Buffer* data, int indentation_delta, struct Chunks* sub_chunks) {\n" >
+        "struct Chunk* chunk = allocate(sizeof(struct Chunk));\n"
+        "chunk->next = NULL;\n"
+        "chunk->data = data;\n"
+        "chunk->chunks = sub_chunks;\n"
+        "chunk->indentation_delta = indentation_delta;\n"
+        "chunks->last->next = chunk;\n"
+        "chunks->last = chunk;\n"
+    < "}\n"
+    "\n"
+    "struct Buffer* create_slice(struct Buffer* data, unsigned int start, unsigned int end) {\n" >
+        "struct Buffer* buffer = allocate(sizeof(struct Buffer));\n"
+        "buffer->buffer = data->buffer;\n"
+        "buffer->size = end-start;\n"
+        "buffer->buffer += start;\n"
+        "return buffer;\n"
+    < "}\n"
+    "\n"
+    "void run_action(struct Action* action, struct Runtime* runtime) {\n" >
+        "if (action->function) {\n" >
+            "if (action->variables) {\n" >
+                "append_data(runtime->current_chunks, create_slice(action->input_buffer, action->start, action->end), 0, NULL);\n"
+            < "} else {\n" >
+                "struct Variable* variable = action->variables->pre_first->next;\n"
+                "while (variable) {\n" >
+                    "run_action(variable->action, runtime);\n"
+                    "variable = variable->next;\n"
+                < "}\n"
+            < "}\n"
+        < "} else {\n" >
+            "action->function(runtime, action->variables);\n"
+        < "}\n"
+    < "}\n"
+    "/*\n"
     "\n"
     "def seen(chunks, data):\n" >
         "chunk = chunks.pre_first.next\n"
@@ -206,7 +245,6 @@ file = rule*:xs space !. -> {
     <placeholders
     xs
     "if __name__ == '__main__':\n" >
-        "parse_state = create_parse_state_from_stdin()\n"
         "runtime = create_runtime()\n"
         "action = rule_main(parse_state)\n"
         "if action == ERROR:\n" >
@@ -221,6 +259,14 @@ file = rule*:xs space !. -> {
         <
         "render_chunks(runtime.main_chunks)\n"
     <
+    "*" "/" "\n"
+    "int main(void) {\n" >
+        "arena_limit = 2<<20;\n"
+        "arena_pos = 0;\n"
+        "arena = malloc(arena_limit);\n"
+        "struct ParseState* parse_state = create_parse_state_from_stdin();\n"
+        "printf(parse_state->input_buffer->buffer);\n"
+    < "}\n"
 };
 
 rule = space name:x space '=' space ors:y space ';' -> {
@@ -397,7 +443,7 @@ actionexpr =
 chunkName = name:x -> {
     >namedChunks {
         unseen(x) -> {
-            "named_chunks_" x " = None\n"
+            "struct Chunks* named_chunks_" x ";\n"
         }
     }
     x
@@ -447,7 +493,7 @@ nextname = '.' name;
 wvar = 'W[' .:x ']' -> {
     >namedWs {
         unseen(x) -> {
-            "W_" x " = None\n"
+            "unsigned int W_" x ";\n"
         }
     }
     x
diff --git a/08_translate_to_c/test.sh b/08_translate_to_c/test.sh
index bea2ba8..039bb0c 100755
--- a/08_translate_to_c/test.sh
+++ b/08_translate_to_c/test.sh
@@ -10,7 +10,7 @@ gcc -o experiments experiments.c && ./experiments
 echo "Compiling rlmeta2_meta.py"
 python rlmeta2.py <rlmeta2.rlmeta2 >rlmeta2_meta.py
 python rlmeta2_meta.py <rlmeta2.rlmeta2 >rlmeta2_meta.c
-gcc -o rlmeta2_meta rlmeta2_meta.c && ./rlmeta2_meta
+gcc -o rlmeta2_meta rlmeta2_meta.c && ./rlmeta2_meta <rlmeta2.rlmeta2
 
 #echo "Is metacompiler? Diff rlmeta2_meta.py"
 #diff rlmeta2.py rlmeta2_meta.py

commit cf5fd1048f6da5722084cf86f92fe1dfa1f29a9c
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 16:35:40 2025 +0100

    Set up C compile loop

diff --git a/08_translate_to_c/.gitignore b/08_translate_to_c/.gitignore
index a3b6376..c0c9a39 100644
--- a/08_translate_to_c/.gitignore
+++ b/08_translate_to_c/.gitignore
@@ -1,3 +1,4 @@
 table.py
 rlmeta2_meta.py
+rlmeta2_meta.c
 experiments
diff --git a/08_translate_to_c/test.sh b/08_translate_to_c/test.sh
index 219d5ed..bea2ba8 100755
--- a/08_translate_to_c/test.sh
+++ b/08_translate_to_c/test.sh
@@ -9,22 +9,24 @@ gcc -o experiments experiments.c && ./experiments
 
 echo "Compiling rlmeta2_meta.py"
 python rlmeta2.py <rlmeta2.rlmeta2 >rlmeta2_meta.py
-
-echo "Is metacompiler? Diff rlmeta2_meta.py"
-diff rlmeta2.py rlmeta2_meta.py
-
-echo "Compiling table.py"
-python rlmeta2.py <table.rlmeta2 >table.py
-
-echo "Diffing"
-if diff <(python table.py < table.txt) <(cat <<EOF
-Name     Age
--------  ---
-Rickard  40
-Axel     7
-EOF
-); then
-    echo Diff OK
-fi
-
-python table.py < table.txt
+python rlmeta2_meta.py <rlmeta2.rlmeta2 >rlmeta2_meta.c
+gcc -o rlmeta2_meta rlmeta2_meta.c && ./rlmeta2_meta
+
+#echo "Is metacompiler? Diff rlmeta2_meta.py"
+#diff rlmeta2.py rlmeta2_meta.py
+#
+#echo "Compiling table.py"
+#python rlmeta2.py <table.rlmeta2 >table.py
+#
+#echo "Diffing"
+#if diff <(python table.py < table.txt) <(cat <<EOF
+#Name     Age
+#-------  ---
+#Rickard  40
+#Axel     7
+#EOF
+#); then
+#    echo Diff OK
+#fi
+#
+#python table.py < table.txt

commit 279d832f9ceaa81d93878115e13efb60fab7e62f
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 16:33:24 2025 +0100

    Make experiments in C

diff --git a/08_translate_to_c/.gitignore b/08_translate_to_c/.gitignore
index 081d42c..a3b6376 100644
--- a/08_translate_to_c/.gitignore
+++ b/08_translate_to_c/.gitignore
@@ -1,2 +1,3 @@
 table.py
 rlmeta2_meta.py
+experiments
diff --git a/08_translate_to_c/experiments.c b/08_translate_to_c/experiments.c
new file mode 100644
index 0000000..c191312
--- /dev/null
+++ b/08_translate_to_c/experiments.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+typedef struct {
+    int foo;
+    char bar;
+} Foo;
+
+typedef struct {
+    int foo;
+    char bar1;
+    char bar2;
+    char bar3;
+    char bar4;
+    char bar5;
+} Bar;
+
+int main(void) {
+    printf("Sizeof char      = %d\n", sizeof(char));
+    printf("Sizeof short     = %d\n", sizeof(short));
+    printf("Sizeof int       = %d\n", sizeof(int));
+    printf("Sizeof long      = %d\n", sizeof(long));
+    printf("Sizeof long long = %d\n", sizeof(long long));
+    printf("Sizeof pointer   = %d\n", sizeof(void *));
+    printf("Sizeof Foo       = %d\n", sizeof(Foo));
+    printf("Sizeof Bar       = %d\n", sizeof(Bar));
+}
diff --git a/08_translate_to_c/test.sh b/08_translate_to_c/test.sh
index b5fce01..219d5ed 100755
--- a/08_translate_to_c/test.sh
+++ b/08_translate_to_c/test.sh
@@ -4,6 +4,9 @@ set -e
 
 cd "$(dirname "$0")"
 
+echo "Running experiments"
+gcc -o experiments experiments.c && ./experiments
+
 echo "Compiling rlmeta2_meta.py"
 python rlmeta2.py <rlmeta2.rlmeta2 >rlmeta2_meta.py
 

commit 517e428b23b5fce6a01b17674802ff232457039e
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 16:25:51 2025 +0100

    Create 08_translate_to_c

diff --git a/08_translate_to_c/.gitignore b/08_translate_to_c/.gitignore
new file mode 100644
index 0000000..081d42c
--- /dev/null
+++ b/08_translate_to_c/.gitignore
@@ -0,0 +1,2 @@
+table.py
+rlmeta2_meta.py
diff --git a/08_translate_to_c/accept.sh b/08_translate_to_c/accept.sh
new file mode 100755
index 0000000..7e120b6
--- /dev/null
+++ b/08_translate_to_c/accept.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -e
+
+cd "$(dirname "$0")"
+
+mv rlmeta2_meta.py rlmeta2.py
+
+./test.sh
diff --git a/08_translate_to_c/rlmeta2.py b/08_translate_to_c/rlmeta2.py
new file mode 100644
index 0000000..71d6dde
--- /dev/null
+++ b/08_translate_to_c/rlmeta2.py
@@ -0,0 +1,2392 @@
+import sys
+
+class ParseState:
+    input_buffer = None
+    pos = None
+
+class Runtime:
+    main_chunks = None
+    named_chunks_namedChunks = None
+    named_chunks_namedWs = None
+    named_chunks_actions = None
+    named_chunks_placeholders = None
+    current_chunks = None
+    W_0 = None
+    W_1 = None
+    placeholders = None
+
+class Action:
+    function = None
+    variables = None
+    input_buffer = None
+    start = None
+    end = None
+    len = None
+
+class Variables:
+    pre_first = None
+    last = None
+
+class Variable:
+    next = None
+    name = None
+    action = None
+
+class Chunks:
+    pre_first = None
+    last = None
+    seen = None
+
+class Chunk:
+    next = None
+    data = None
+    chunks = None
+    indentation_delta = None
+
+class Placeholders:
+    pre_first = None
+    last = None
+
+class Placeholder:
+    next = None
+    chunks = None
+    action = None
+
+def create_parse_state_from_stdin():
+    parse_state = ParseState()
+    parse_state.input_buffer = sys.stdin.buffer.read()
+    parse_state.pos = 0
+    return parse_state
+
+def create_runtime():
+    runtime = Runtime()
+    runtime.main_chunks = create_chunks()
+    runtime.current_chunks = runtime.main_chunks
+    runtime.placeholders = create_placeholders()
+    return runtime
+
+def create_action(function, variables, input_buffer, start, end):
+    action = Action()
+    action.function = function
+    action.variables = variables
+    action.input_buffer = input_buffer
+    action.start = start
+    action.end = end
+    action.len = end-start
+    return action
+
+def create_variables():
+    variables = Variables()
+    variables.pre_first = Variable()
+    variables.last = variables.pre_first
+    return variables
+
+def create_chunks():
+    chunks = Chunks()
+    chunks.pre_first = Chunk()
+    chunks.last = chunks.pre_first
+    return chunks
+
+def create_placeholders():
+    placeholders = Placeholder()
+    placeholders.pre_first = Placeholder()
+    placeholders.last = placeholders.pre_first
+    return placeholders
+
+def run_action(action, runtime):
+    if action.function is None:
+        if action.variables is None:
+            append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)
+        else:
+            variable = action.variables.pre_first.next
+            while variable:
+                run_action(variable.action, runtime)
+                variable = variable.next
+    else:
+        action.function(runtime, action.variables)
+
+def append_data(chunks, data, indentation_delta, sub_chunks=None):
+    chunk = Chunk()
+    chunk.next = None
+    chunk.data = data
+    chunk.chunks = sub_chunks
+    chunk.indentation_delta = indentation_delta
+    chunks.last.next = chunk
+    chunks.last = chunk
+
+def seen(chunks, data):
+    chunk = chunks.pre_first.next
+    while chunk:
+        if chunk.data == data:
+            return True
+        chunk = chunk.next
+    return False
+
+def append_named_action(variables, name, action):
+    next_variable = Variable()
+    next_variable.next = None
+    next_variable.name = name
+    next_variable.action = action
+    variables.last.next = next_variable
+    variables.last = next_variable
+
+def lookup_action(variables, name_to_look_for):
+    variable = variables.pre_first.next
+    while variable:
+        if variable.name == name_to_look_for:
+            return variable.action
+        else:
+            variable = variable.next
+    raise ValueError(f'variable {name_to_look_for} not found')
+
+def append_placeholder(placeholders, chunks, action):
+    next_variable = Placeholder()
+    next_variable.next = None
+    next_variable.chunks = chunks
+    next_variable.action = action
+    placeholders.last.next = next_variable
+    placeholders.last = next_variable
+
+def inc(value, amount):
+    return value + amount
+
+def render_chunks(chunks, last_char=b'\n', indent=0):
+    if chunks:
+        chunk = chunks.pre_first.next
+        while chunk:
+            indent += chunk.indentation_delta
+            for char in chunk.data:
+                if last_char == b'\n':
+                    sys.stdout.buffer.write(b'    '*indent)
+                last_char = char.to_bytes()
+                sys.stdout.buffer.write(last_char)
+            last_char, indent = render_chunks(chunk.chunks, last_char, indent)
+            chunk = chunk.next
+    return last_char, indent
+
+ERROR = -1
+
+def action_1(runtime, variables):
+    pass
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_2(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"import sys\n", 0)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class ParseState:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"input_buffer = None\n", 0)
+    append_data(runtime.current_chunks, b"pos = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Runtime:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"main_chunks = None\n", 0)
+    chunks = create_chunks()
+    runtime.named_chunks_namedChunks = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
+    append_data(runtime.current_chunks, b"current_chunks = None\n", 0)
+    chunks = create_chunks()
+    runtime.named_chunks_namedWs = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
+    append_data(runtime.current_chunks, b"placeholders = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Action:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"function = None\n", 0)
+    append_data(runtime.current_chunks, b"variables = None\n", 0)
+    append_data(runtime.current_chunks, b"input_buffer = None\n", 0)
+    append_data(runtime.current_chunks, b"start = None\n", 0)
+    append_data(runtime.current_chunks, b"end = None\n", 0)
+    append_data(runtime.current_chunks, b"len = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Variables:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunks, b"last = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Variable:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next = None\n", 0)
+    append_data(runtime.current_chunks, b"name = None\n", 0)
+    append_data(runtime.current_chunks, b"action = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Chunks:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunks, b"last = None\n", 0)
+    append_data(runtime.current_chunks, b"seen = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Chunk:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next = None\n", 0)
+    append_data(runtime.current_chunks, b"data = None\n", 0)
+    append_data(runtime.current_chunks, b"chunks = None\n", 0)
+    append_data(runtime.current_chunks, b"indentation_delta = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Placeholders:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunks, b"last = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Placeholder:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next = None\n", 0)
+    append_data(runtime.current_chunks, b"chunks = None\n", 0)
+    append_data(runtime.current_chunks, b"action = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_parse_state_from_stdin():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state = ParseState()\n", 0)
+    append_data(runtime.current_chunks, b"parse_state.input_buffer = sys.stdin.buffer.read()\n", 0)
+    append_data(runtime.current_chunks, b"parse_state.pos = 0\n", 0)
+    append_data(runtime.current_chunks, b"return parse_state\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_runtime():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"runtime = Runtime()\n", 0)
+    append_data(runtime.current_chunks, b"runtime.main_chunks = create_chunks()\n", 0)
+    append_data(runtime.current_chunks, b"runtime.current_chunks = runtime.main_chunks\n", 0)
+    append_data(runtime.current_chunks, b"runtime.placeholders = create_placeholders()\n", 0)
+    append_data(runtime.current_chunks, b"return runtime\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_action(function, variables, input_buffer, start, end):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"action = Action()\n", 0)
+    append_data(runtime.current_chunks, b"action.function = function\n", 0)
+    append_data(runtime.current_chunks, b"action.variables = variables\n", 0)
+    append_data(runtime.current_chunks, b"action.input_buffer = input_buffer\n", 0)
+    append_data(runtime.current_chunks, b"action.start = start\n", 0)
+    append_data(runtime.current_chunks, b"action.end = end\n", 0)
+    append_data(runtime.current_chunks, b"action.len = end-start\n", 0)
+    append_data(runtime.current_chunks, b"return action\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_variables():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variables = Variables()\n", 0)
+    append_data(runtime.current_chunks, b"variables.pre_first = Variable()\n", 0)
+    append_data(runtime.current_chunks, b"variables.last = variables.pre_first\n", 0)
+    append_data(runtime.current_chunks, b"return variables\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_chunks():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"chunks = Chunks()\n", 0)
+    append_data(runtime.current_chunks, b"chunks.pre_first = Chunk()\n", 0)
+    append_data(runtime.current_chunks, b"chunks.last = chunks.pre_first\n", 0)
+    append_data(runtime.current_chunks, b"return chunks\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_placeholders():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"placeholders = Placeholder()\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.pre_first = Placeholder()\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.last = placeholders.pre_first\n", 0)
+    append_data(runtime.current_chunks, b"return placeholders\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def run_action(action, runtime):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if action.function is None:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if action.variables is None:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variable = action.variables.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while variable:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"run_action(variable.action, runtime)\n", 0)
+    append_data(runtime.current_chunks, b"variable = variable.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"action.function(runtime, action.variables)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def append_data(chunks, data, indentation_delta, sub_chunks=None):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"chunk = Chunk()\n", 0)
+    append_data(runtime.current_chunks, b"chunk.next = None\n", 0)
+    append_data(runtime.current_chunks, b"chunk.data = data\n", 0)
+    append_data(runtime.current_chunks, b"chunk.chunks = sub_chunks\n", 0)
+    append_data(runtime.current_chunks, b"chunk.indentation_delta = indentation_delta\n", 0)
+    append_data(runtime.current_chunks, b"chunks.last.next = chunk\n", 0)
+    append_data(runtime.current_chunks, b"chunks.last = chunk\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def seen(chunks, data):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"chunk = chunks.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while chunk:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if chunk.data == data:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"return True\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"chunk = chunk.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"return False\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def append_named_action(variables, name, action):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next_variable = Variable()\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.next = None\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.name = name\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.action = action\n", 0)
+    append_data(runtime.current_chunks, b"variables.last.next = next_variable\n", 0)
+    append_data(runtime.current_chunks, b"variables.last = next_variable\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def lookup_action(variables, name_to_look_for):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variable = variables.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while variable:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if variable.name == name_to_look_for:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"return variable.action\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variable = variable.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def append_placeholder(placeholders, chunks, action):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next_variable = Placeholder()\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.next = None\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.chunks = chunks\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.action = action\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.last.next = next_variable\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.last = next_variable\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def inc(value, amount):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"return value + amount\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def render_chunks(chunks, last_char=b'\\n', indent=0):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if chunks:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"chunk = chunks.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while chunk:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"indent += chunk.indentation_delta\n", 0)
+    append_data(runtime.current_chunks, b"for char in chunk.data:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if last_char == b'\\n':\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"sys.stdout.buffer.write(b'    '*indent)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"last_char = char.to_bytes()\n", 0)
+    append_data(runtime.current_chunks, b"sys.stdout.buffer.write(last_char)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"last_char, indent = render_chunks(chunk.chunks, last_char, indent)\n", 0)
+    append_data(runtime.current_chunks, b"chunk = chunk.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"return last_char, indent\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"ERROR = -1\n", 0)
+    append_data(runtime.current_chunks, b"\n", 0)
+    chunks = create_chunks()
+    runtime.named_chunks_actions = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
+    chunks = create_chunks()
+    runtime.named_chunks_placeholders = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
+    run_action(lookup_action(variables, 'xs'), runtime)
+    append_data(runtime.current_chunks, b"if __name__ == '__main__':\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state = create_parse_state_from_stdin()\n", 0)
+    append_data(runtime.current_chunks, b"runtime = create_runtime()\n", 0)
+    append_data(runtime.current_chunks, b"action = rule_main(parse_state)\n", 0)
+    append_data(runtime.current_chunks, b"if action == ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"sys.exit('Parse error')\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"run_action(action, runtime)\n", 0)
+    append_data(runtime.current_chunks, b"placeholder = runtime.placeholders.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while placeholder:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"runtime.current_chunks = placeholder.chunks\n", 0)
+    append_data(runtime.current_chunks, b"run_action(placeholder.action, runtime)\n", 0)
+    append_data(runtime.current_chunks, b"placeholder = placeholder.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"render_chunks(runtime.main_chunks)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+
+def action_3(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"def rule_", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"(parse_state):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+
+def action_4(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"or_backtrack_pos = parse_state.pos\n", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    run_action(lookup_action(variables, 'xs'), runtime)
+    append_data(runtime.current_chunks, b"return ERROR\n", 0)
+
+def action_5(runtime, variables):
+    pass
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_6(runtime, variables):
+    pass
+
+def action_7(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"parse_state.pos = or_backtrack_pos\n", 0)
+    append_data(runtime.current_chunks, b"action_start_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunks, b"variables = create_variables()\n", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_8(runtime, variables):
+    pass
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"if _ != ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b'', -1)
+
+def action_9(runtime, variables):
+    pass
+    run_action(lookup_action(variables, 'y'), runtime)
+
+def action_10(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"nlookahead_pos = parse_state.pos\n", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"if _ == ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = lambda: None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"parse_state.pos = nlookahead_pos\n", 0)
+
+def action_11(runtime, variables):
+    pass
+    run_action(lookup_action(variables, 'x'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
+
+def action_12(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"append_named_action(variables, '", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"', _)\n", 0)
+
+def action_13(runtime, variables):
+    pass
+
+def action_14(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"star_variables = create_variables()\n", 0)
+    append_data(runtime.current_chunks, b"star_start_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunks, b"while True:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"star_pos = parse_state.pos\n", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"if _ == ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state.pos = star_pos\n", 0)
+    append_data(runtime.current_chunks, b"break\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"append_named_action(star_variables, None, _)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+
+def action_15(runtime, variables):
+    pass
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_16(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"_ = rule_", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"(parse_state)\n", 0)
+
+def action_17(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state.pos += 1\n", 0)
+    append_data(runtime.current_chunks, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+
+def action_18(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"data = b", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state.pos += len(data)\n", 0)
+    append_data(runtime.current_chunks, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+
+def action_19(runtime, variables):
+    pass
+    runtime.W_0 = inc(runtime.W_0 or 0, 1)
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_actions
+    runtime.current_chunks = chunks
+    append_data(runtime.current_chunks, b"def action_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_0 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b"(runtime, variables):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pass\n", 0)
+    run_action(lookup_action(variables, 'xs'), runtime)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    runtime.current_chunks = last_chunks
+    append_data(runtime.current_chunks, b"return create_action(action_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_0 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+
+def action_20(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+
+def action_21(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"action = lookup_action(variables, '", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"')\n", 0)
+    append_data(runtime.current_chunks, b"if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pass\n", 0)
+    run_action(lookup_action(variables, 'ys'), runtime)
+    append_data(runtime.current_chunks, b'', -1)
+
+def action_22(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"last_chunks = runtime.current_chunks\n", 0)
+    append_data(runtime.current_chunks, b"chunks = runtime.named_chunks_", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"runtime.current_chunks = chunks\n", 0)
+    run_action(lookup_action(variables, 'ys'), runtime)
+    append_data(runtime.current_chunks, b"runtime.current_chunks = last_chunks\n", 0)
+
+def action_23(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"chunks = create_chunks()\n", 0)
+    append_data(runtime.current_chunks, b"runtime.named_chunks_", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b" = chunks\n", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 0, chunks)\n", 0)
+
+def action_24(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, str(", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b").encode('ascii'), 0)\n", 0)
+
+def action_25(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"run_action(lookup_action(variables, '", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"'), runtime)\n", 0)
+
+def action_26(runtime, variables):
+    pass
+    runtime.W_1 = inc(runtime.W_1 or 0, 1)
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_placeholders
+    runtime.current_chunks = chunks
+    append_data(runtime.current_chunks, b"def placeholder_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_1 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b"(runtime, variables):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pass\n", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    runtime.current_chunks = last_chunks
+    append_data(runtime.current_chunks, b"chunks = create_chunks()\n", 0)
+    append_data(runtime.current_chunks, b"append_placeholder(runtime.placeholders, chunks, create_action(placeholder_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_1 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b", variables, '', 0, 0))\n", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 0, chunks)\n", 0)
+
+def action_27(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b", 0)\n", 0)
+
+def action_28(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"runtime.W_", 0)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b" = ", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"(runtime.W_", 0)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b" or 0, ", 0)
+    run_action(lookup_action(variables, 'z'), runtime)
+    append_data(runtime.current_chunks, b")\n", 0)
+
+def action_29(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 1)\n", 0)
+    run_action(lookup_action(variables, 'xs'), runtime)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', -1)\n", 0)
+
+def action_30(runtime, variables):
+    pass
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_namedChunks
+    runtime.current_chunks = chunks
+    action = lookup_action(variables, 'x')
+    if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):
+        pass
+        append_data(runtime.current_chunks, b"named_chunks_", 0)
+        run_action(lookup_action(variables, 'x'), runtime)
+        append_data(runtime.current_chunks, b" = None\n", 0)
+    runtime.current_chunks = last_chunks
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_31(runtime, variables):
+    pass
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_32(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"*", 0)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b", 0)\n", 0)
+
+def action_33(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"(runtime.W_", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b" or 0)", 0)
+
+def action_34(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"((runtime.W_", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b" or 0)-", 0)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b")", 0)
+
+def action_35(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"lookup_action(variables, '", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"')", 0)
+    run_action(lookup_action(variables, 'xs'), runtime)
+
+def action_36(runtime, variables):
+    pass
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_namedWs
+    runtime.current_chunks = chunks
+    action = lookup_action(variables, 'x')
+    if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):
+        pass
+        append_data(runtime.current_chunks, b"W_", 0)
+        run_action(lookup_action(variables, 'x'), runtime)
+        append_data(runtime.current_chunks, b" = None\n", 0)
+    runtime.current_chunks = last_chunks
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_37(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"'", 0)
+
+def rule_main(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_file(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_1, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_file(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    star_variables = create_variables()
+    star_start_pos = parse_state.pos
+    while True:
+        star_pos = parse_state.pos
+        _ = rule_rule(parse_state)
+        if _ == ERROR:
+            parse_state.pos = star_pos
+            break
+        append_named_action(star_variables, None, _)
+    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+    append_named_action(variables, 'xs', _)
+    if _ != ERROR:
+        _ = rule_space(parse_state)
+        if _ != ERROR:
+            nlookahead_pos = parse_state.pos
+            if parse_state.pos != len(parse_state.input_buffer):
+                parse_state.pos += 1
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+            else:
+                _ = ERROR
+            if _ == ERROR:
+                _ = lambda: None
+            else:
+                _ = ERROR
+            parse_state.pos = nlookahead_pos
+            if _ != ERROR:
+                return create_action(action_2, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_rule(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        _ = rule_name(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            _ = rule_space(parse_state)
+            if _ != ERROR:
+                data = b'='
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                else:
+                    _ = ERROR
+                if _ != ERROR:
+                    _ = rule_space(parse_state)
+                    if _ != ERROR:
+                        _ = rule_ors(parse_state)
+                        append_named_action(variables, 'y', _)
+                        if _ != ERROR:
+                            _ = rule_space(parse_state)
+                            if _ != ERROR:
+                                data = b';'
+                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                    parse_state.pos += len(data)
+                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                else:
+                                    _ = ERROR
+                                if _ != ERROR:
+                                    return create_action(action_3, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_ors(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_maybeorbar(parse_state)
+    if _ != ERROR:
+        _ = rule_orcase(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            star_variables = create_variables()
+            star_start_pos = parse_state.pos
+            while True:
+                star_pos = parse_state.pos
+                _ = rule_restorcase(parse_state)
+                if _ == ERROR:
+                    parse_state.pos = star_pos
+                    break
+                append_named_action(star_variables, None, _)
+            _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action(variables, 'xs', _)
+            if _ != ERROR:
+                return create_action(action_4, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_restorcase(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_orbar(parse_state)
+    if _ != ERROR:
+        _ = rule_orcase(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            return create_action(action_5, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_maybeorbar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_orbar(parse_state)
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    return create_action(action_6, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_orbar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'|'
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_orcase(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_matchAnd(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_7, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_matchAnd(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        _ = rule_matchExpr(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            _ = rule_matchAnd(parse_state)
+            append_named_action(variables, 'y', _)
+            if _ != ERROR:
+                return create_action(action_8, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_action(parse_state)
+    append_named_action(variables, 'y', _)
+    if _ != ERROR:
+        return create_action(action_9, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_matchExpr(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'!'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        _ = rule_matchExprPrimitive(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            return create_action(action_10, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_matchExprRepeat(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        _ = rule_matchAssign(parse_state)
+        append_named_action(variables, 'y', _)
+        if _ != ERROR:
+            return create_action(action_11, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_matchAssign(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b':'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        _ = rule_name(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            return create_action(action_12, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    return create_action(action_13, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_matchExprRepeat(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_matchExprPrimitive(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        data = b'*'
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            return create_action(action_14, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_matchExprPrimitive(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_15, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_matchExprPrimitive(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_name(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_16, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'.'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(action_17, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_charstring(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_18, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_action(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'->'
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            _ = rule_space(parse_state)
+            if _ != ERROR:
+                data = b'{'
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                else:
+                    _ = ERROR
+                if _ != ERROR:
+                    star_variables = create_variables()
+                    star_start_pos = parse_state.pos
+                    while True:
+                        star_pos = parse_state.pos
+                        _ = rule_actionexpr(parse_state)
+                        if _ == ERROR:
+                            parse_state.pos = star_pos
+                            break
+                        append_named_action(star_variables, None, _)
+                    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                    append_named_action(variables, 'xs', _)
+                    if _ != ERROR:
+                        _ = rule_space(parse_state)
+                        if _ != ERROR:
+                            data = b'}'
+                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                parse_state.pos += len(data)
+                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                            else:
+                                _ = ERROR
+                            if _ != ERROR:
+                                return create_action(action_19, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    return create_action(action_20, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_actionexpr(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'unseen('
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            _ = rule_name(parse_state)
+            append_named_action(variables, 'x', _)
+            if _ != ERROR:
+                data = b') -> {'
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                else:
+                    _ = ERROR
+                if _ != ERROR:
+                    star_variables = create_variables()
+                    star_start_pos = parse_state.pos
+                    while True:
+                        star_pos = parse_state.pos
+                        _ = rule_actionexpr(parse_state)
+                        if _ == ERROR:
+                            parse_state.pos = star_pos
+                            break
+                        append_named_action(star_variables, None, _)
+                    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                    append_named_action(variables, 'ys', _)
+                    if _ != ERROR:
+                        _ = rule_space(parse_state)
+                        if _ != ERROR:
+                            data = b'}'
+                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                parse_state.pos += len(data)
+                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                            else:
+                                _ = ERROR
+                            if _ != ERROR:
+                                return create_action(action_21, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'>'
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            _ = rule_chunkName(parse_state)
+            append_named_action(variables, 'x', _)
+            if _ != ERROR:
+                _ = rule_space(parse_state)
+                if _ != ERROR:
+                    data = b'{'
+                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                        parse_state.pos += len(data)
+                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                    else:
+                        _ = ERROR
+                    if _ != ERROR:
+                        star_variables = create_variables()
+                        star_start_pos = parse_state.pos
+                        while True:
+                            star_pos = parse_state.pos
+                            _ = rule_actionexpr(parse_state)
+                            if _ == ERROR:
+                                parse_state.pos = star_pos
+                                break
+                            append_named_action(star_variables, None, _)
+                        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                        append_named_action(variables, 'ys', _)
+                        if _ != ERROR:
+                            _ = rule_space(parse_state)
+                            if _ != ERROR:
+                                data = b'}'
+                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                    parse_state.pos += len(data)
+                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                else:
+                                    _ = ERROR
+                                if _ != ERROR:
+                                    return create_action(action_22, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'<'
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            _ = rule_chunkName(parse_state)
+            append_named_action(variables, 'x', _)
+            if _ != ERROR:
+                return create_action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        _ = rule_expr(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            return create_action(action_24, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        _ = rule_name(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            return create_action(action_25, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        _ = rule_placeholder(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            return create_action(action_26, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        _ = rule_string(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            return create_action(action_27, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'#'
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            _ = rule_name(parse_state)
+            append_named_action(variables, 'x', _)
+            if _ != ERROR:
+                data = b'('
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                else:
+                    _ = ERROR
+                if _ != ERROR:
+                    _ = rule_wvar(parse_state)
+                    append_named_action(variables, 'y', _)
+                    if _ != ERROR:
+                        data = b' '
+                        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                            parse_state.pos += len(data)
+                            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                        else:
+                            _ = ERROR
+                        if _ != ERROR:
+                            _ = rule_actionPrimitiveExpression(parse_state)
+                            append_named_action(variables, 'z', _)
+                            if _ != ERROR:
+                                data = b')'
+                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                    parse_state.pos += len(data)
+                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                else:
+                                    _ = ERROR
+                                if _ != ERROR:
+                                    return create_action(action_28, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'>'
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            star_variables = create_variables()
+            star_start_pos = parse_state.pos
+            while True:
+                star_pos = parse_state.pos
+                _ = rule_actionexpr(parse_state)
+                if _ == ERROR:
+                    parse_state.pos = star_pos
+                    break
+                append_named_action(star_variables, None, _)
+            _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action(variables, 'xs', _)
+            if _ != ERROR:
+                _ = rule_space(parse_state)
+                if _ != ERROR:
+                    data = b'<'
+                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                        parse_state.pos += len(data)
+                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                    else:
+                        _ = ERROR
+                    if _ != ERROR:
+                        return create_action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_chunkName(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_name(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_actionPrimitiveExpression(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_dotname(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_digit(parse_state)
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_digit(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'0'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'1'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'2'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'3'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'4'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'5'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'6'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'7'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'8'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'9'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_placeholder(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'{'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        _ = rule_space(parse_state)
+        if _ != ERROR:
+            _ = rule_string(parse_state)
+            append_named_action(variables, 'x', _)
+            if _ != ERROR:
+                data = b'*'
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                else:
+                    _ = ERROR
+                if _ != ERROR:
+                    _ = rule_expr(parse_state)
+                    append_named_action(variables, 'y', _)
+                    if _ != ERROR:
+                        _ = rule_space(parse_state)
+                        if _ != ERROR:
+                            data = b'}'
+                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                parse_state.pos += len(data)
+                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                            else:
+                                _ = ERROR
+                            if _ != ERROR:
+                                return create_action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_expr(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_wvar(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'('
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        _ = rule_wvar(parse_state)
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            data = b'-'
+            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                parse_state.pos += len(data)
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            else:
+                _ = ERROR
+            if _ != ERROR:
+                _ = rule_dotname(parse_state)
+                append_named_action(variables, 'y', _)
+                if _ != ERROR:
+                    data = b')'
+                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                        parse_state.pos += len(data)
+                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                    else:
+                        _ = ERROR
+                    if _ != ERROR:
+                        return create_action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_string(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'"'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        star_variables = create_variables()
+        star_start_pos = parse_state.pos
+        while True:
+            star_pos = parse_state.pos
+            _ = rule_stringinner(parse_state)
+            if _ == ERROR:
+                parse_state.pos = star_pos
+                break
+            append_named_action(star_variables, None, _)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        if _ != ERROR:
+            data = b'"'
+            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                parse_state.pos += len(data)
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            else:
+                _ = ERROR
+            if _ != ERROR:
+                return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_dotname(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_name(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        star_variables = create_variables()
+        star_start_pos = parse_state.pos
+        while True:
+            star_pos = parse_state.pos
+            _ = rule_nextname(parse_state)
+            if _ == ERROR:
+                parse_state.pos = star_pos
+                break
+            append_named_action(star_variables, None, _)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        append_named_action(variables, 'xs', _)
+        if _ != ERROR:
+            return create_action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_nextname(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'.'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        _ = rule_name(parse_state)
+        if _ != ERROR:
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_wvar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'W['
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        if parse_state.pos != len(parse_state.input_buffer):
+            parse_state.pos += 1
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+        else:
+            _ = ERROR
+        append_named_action(variables, 'x', _)
+        if _ != ERROR:
+            data = b']'
+            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                parse_state.pos += len(data)
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            else:
+                _ = ERROR
+            if _ != ERROR:
+                return create_action(action_36, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_stringinner(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    nlookahead_pos = parse_state.pos
+    _ = rule_stringend(parse_state)
+    if _ == ERROR:
+        _ = lambda: None
+    else:
+        _ = ERROR
+    parse_state.pos = nlookahead_pos
+    if _ != ERROR:
+        if parse_state.pos != len(parse_state.input_buffer):
+            parse_state.pos += 1
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_stringend(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'"'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_charstring(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_quote(parse_state)
+    if _ != ERROR:
+        star_variables = create_variables()
+        star_start_pos = parse_state.pos
+        while True:
+            star_pos = parse_state.pos
+            _ = rule_innercharstring(parse_state)
+            if _ == ERROR:
+                parse_state.pos = star_pos
+                break
+            append_named_action(star_variables, None, _)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        if _ != ERROR:
+            _ = rule_quote(parse_state)
+            if _ != ERROR:
+                return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_quote(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'\''
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_innercharstring(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'\\\''
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(action_37, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    nlookahead_pos = parse_state.pos
+    _ = rule_quote(parse_state)
+    if _ == ERROR:
+        _ = lambda: None
+    else:
+        _ = ERROR
+    parse_state.pos = nlookahead_pos
+    if _ != ERROR:
+        if parse_state.pos != len(parse_state.input_buffer):
+            parse_state.pos += 1
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_name(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_char(parse_state)
+    if _ != ERROR:
+        star_variables = create_variables()
+        star_start_pos = parse_state.pos
+        while True:
+            star_pos = parse_state.pos
+            _ = rule_char(parse_state)
+            if _ == ERROR:
+                parse_state.pos = star_pos
+                break
+            append_named_action(star_variables, None, _)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        if _ != ERROR:
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_char(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'a'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'b'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'c'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'd'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'e'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'f'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'g'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'h'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'i'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'j'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'k'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'l'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'm'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'n'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'o'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'p'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'q'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'r'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b's'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b't'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'u'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'v'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'w'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'x'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'y'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'z'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'A'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'B'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'C'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'D'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'E'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'F'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'G'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'H'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'I'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'J'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'K'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'L'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'M'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'N'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'O'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'P'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'Q'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'R'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'S'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'T'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'U'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'V'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'W'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'X'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'Y'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'Z'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_space(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    star_variables = create_variables()
+    star_start_pos = parse_state.pos
+    while True:
+        star_pos = parse_state.pos
+        _ = rule_spacechar(parse_state)
+        if _ == ERROR:
+            parse_state.pos = star_pos
+            break
+        append_named_action(star_variables, None, _)
+    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+def rule_spacechar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b' '
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    data = b'\n'
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+    else:
+        _ = ERROR
+    if _ != ERROR:
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
+if __name__ == '__main__':
+    parse_state = create_parse_state_from_stdin()
+    runtime = create_runtime()
+    action = rule_main(parse_state)
+    if action == ERROR:
+        sys.exit('Parse error')
+    run_action(action, runtime)
+    placeholder = runtime.placeholders.pre_first.next
+    while placeholder:
+        runtime.current_chunks = placeholder.chunks
+        run_action(placeholder.action, runtime)
+        placeholder = placeholder.next
+    render_chunks(runtime.main_chunks)
diff --git a/08_translate_to_c/rlmeta2.rlmeta2 b/08_translate_to_c/rlmeta2.rlmeta2
new file mode 100644
index 0000000..64c0e64
--- /dev/null
+++ b/08_translate_to_c/rlmeta2.rlmeta2
@@ -0,0 +1,475 @@
+main = file:x -> { x };
+
+file = rule*:xs space !. -> {
+    "import sys\n"
+    "\n"
+    "class ParseState:\n" >
+        "input_buffer = None\n"
+        "pos = None\n"
+    <
+    "\n"
+    "class Runtime:\n" >
+        "main_chunks = None\n"
+        <namedChunks
+        "current_chunks = None\n"
+        <namedWs
+        "placeholders = None\n"
+    <
+    "\n"
+    "class Action:\n" >
+        "function = None\n"
+        "variables = None\n"
+        "input_buffer = None\n"
+        "start = None\n"
+        "end = None\n"
+        "len = None\n"
+    <
+    "\n"
+    "class Variables:\n" >
+        "pre_first = None\n"
+        "last = None\n"
+    <
+    "\n"
+    "class Variable:\n" >
+        "next = None\n"
+        "name = None\n"
+        "action = None\n"
+    <
+    "\n"
+    "class Chunks:\n" >
+        "pre_first = None\n"
+        "last = None\n"
+        "seen = None\n"
+    <
+    "\n"
+    "class Chunk:\n" >
+        "next = None\n"
+        "data = None\n"
+        "chunks = None\n"
+        "indentation_delta = None\n"
+    <
+    "\n"
+    "class Placeholders:\n" >
+        "pre_first = None\n"
+        "last = None\n"
+    <
+    "\n"
+    "class Placeholder:\n" >
+        "next = None\n"
+        "chunks = None\n"
+        "action = None\n"
+    <
+    "\n"
+    "def create_parse_state_from_stdin():\n" >
+        "parse_state = ParseState()\n"
+        "parse_state.input_buffer = sys.stdin.buffer.read()\n"
+        "parse_state.pos = 0\n"
+        "return parse_state\n"
+    <
+    "\n"
+    "def create_runtime():\n" >
+        "runtime = Runtime()\n"
+        "runtime.main_chunks = create_chunks()\n"
+        "runtime.current_chunks = runtime.main_chunks\n"
+        "runtime.placeholders = create_placeholders()\n"
+        "return runtime\n"
+    <
+    "\n"
+    "def create_action(function, variables, input_buffer, start, end):\n" >
+        "action = Action()\n"
+        "action.function = function\n"
+        "action.variables = variables\n"
+        "action.input_buffer = input_buffer\n"
+        "action.start = start\n"
+        "action.end = end\n"
+        "action.len = end-start\n"
+        "return action\n"
+    <
+    "\n"
+    "def create_variables():\n" >
+        "variables = Variables()\n"
+        "variables.pre_first = Variable()\n"
+        "variables.last = variables.pre_first\n"
+        "return variables\n"
+    <
+    "\n"
+    "def create_chunks():\n" >
+        "chunks = Chunks()\n"
+        "chunks.pre_first = Chunk()\n"
+        "chunks.last = chunks.pre_first\n"
+        "return chunks\n"
+    <
+    "\n"
+    "def create_placeholders():\n" >
+        "placeholders = Placeholder()\n"
+        "placeholders.pre_first = Placeholder()\n"
+        "placeholders.last = placeholders.pre_first\n"
+        "return placeholders\n"
+    <
+    "\n"
+    "def run_action(action, runtime):\n" >
+        "if action.function is None:\n" >
+            "if action.variables is None:\n" >
+                "append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)\n"
+            <
+            "else:\n" >
+                "variable = action.variables.pre_first.next\n"
+                "while variable:\n" >
+                    "run_action(variable.action, runtime)\n"
+                    "variable = variable.next\n"
+                <
+            <
+        <
+        "else:\n" >
+            "action.function(runtime, action.variables)\n"
+        <
+    <
+    "\n"
+    "def append_data(chunks, data, indentation_delta, sub_chunks=None):\n" >
+        "chunk = Chunk()\n"
+        "chunk.next = None\n"
+        "chunk.data = data\n"
+        "chunk.chunks = sub_chunks\n"
+        "chunk.indentation_delta = indentation_delta\n"
+        "chunks.last.next = chunk\n"
+        "chunks.last = chunk\n"
+    <
+    "\n"
+    "def seen(chunks, data):\n" >
+        "chunk = chunks.pre_first.next\n"
+        "while chunk:\n" >
+            "if chunk.data == data:\n" >
+                "return True\n"
+            <
+            "chunk = chunk.next\n"
+        <
+        "return False\n"
+    <
+    "\n"
+    "def append_named_action(variables, name, action):\n" >
+        "next_variable = Variable()\n"
+        "next_variable.next = None\n"
+        "next_variable.name = name\n"
+        "next_variable.action = action\n"
+        "variables.last.next = next_variable\n"
+        "variables.last = next_variable\n"
+    <
+    "\n"
+    "def lookup_action(variables, name_to_look_for):\n" >
+        "variable = variables.pre_first.next\n"
+        "while variable:\n" >
+            "if variable.name == name_to_look_for:\n" >
+                "return variable.action\n"
+            <
+            "else:\n" >
+                "variable = variable.next\n"
+            <
+        <
+        "raise ValueError(f'variable {name_to_look_for} not found')\n"
+    <
+    "\n"
+    "def append_placeholder(placeholders, chunks, action):\n" >
+        "next_variable = Placeholder()\n"
+        "next_variable.next = None\n"
+        "next_variable.chunks = chunks\n"
+        "next_variable.action = action\n"
+        "placeholders.last.next = next_variable\n"
+        "placeholders.last = next_variable\n"
+    <
+    "\n"
+    "def inc(value, amount):\n" >
+        "return value + amount\n"
+    <
+    "\n"
+    "def render_chunks(chunks, last_char=b'\\n', indent=0):\n" >
+        "if chunks:\n" >
+            "chunk = chunks.pre_first.next\n"
+            "while chunk:\n" >
+                "indent += chunk.indentation_delta\n"
+                "for char in chunk.data:\n" >
+                    "if last_char == b'\\n':\n" >
+                        "sys.stdout.buffer.write(b'    '*indent)\n"
+                    <
+                    "last_char = char.to_bytes()\n"
+                    "sys.stdout.buffer.write(last_char)\n"
+                <
+                "last_char, indent = render_chunks(chunk.chunks, last_char, indent)\n"
+                "chunk = chunk.next\n"
+            <
+        <
+        "return last_char, indent\n"
+    <
+    "\n"
+    "ERROR = -1\n"
+    "\n"
+    <actions
+    <placeholders
+    xs
+    "if __name__ == '__main__':\n" >
+        "parse_state = create_parse_state_from_stdin()\n"
+        "runtime = create_runtime()\n"
+        "action = rule_main(parse_state)\n"
+        "if action == ERROR:\n" >
+            "sys.exit('Parse error')\n"
+        <
+        "run_action(action, runtime)\n"
+        "placeholder = runtime.placeholders.pre_first.next\n"
+        "while placeholder:\n" >
+            "runtime.current_chunks = placeholder.chunks\n"
+            "run_action(placeholder.action, runtime)\n"
+            "placeholder = placeholder.next\n"
+        <
+        "render_chunks(runtime.main_chunks)\n"
+    <
+};
+
+rule = space name:x space '=' space ors:y space ';' -> {
+    "def rule_" x "(parse_state):\n" >
+        y
+    <
+    "\n"
+};
+
+ors = maybeorbar orcase:x restorcase*:xs -> {
+    "or_backtrack_pos = parse_state.pos\n"
+    x
+    xs
+    "return ERROR\n"
+};
+
+restorcase = orbar orcase:x -> { x };
+
+maybeorbar = orbar | -> {};
+
+orbar = space '|';
+
+orcase = matchAnd:x -> {
+    "parse_state.pos = or_backtrack_pos\n"
+    "action_start_pos = parse_state.pos\n"
+    "variables = create_variables()\n"
+    x
+};
+
+matchAnd =
+    | space matchExpr:x matchAnd:y -> {
+        x
+        "if _ != ERROR:\n" >
+            y
+        <
+    }
+    | action:y -> { y }
+    ;
+
+matchExpr =
+    | '!' matchExprPrimitive:x -> {
+        "nlookahead_pos = parse_state.pos\n"
+        x
+        "if _ == ERROR:\n" >
+            "_ = lambda: None\n"
+        <
+        "else:\n" >
+            "_ = ERROR\n"
+        <
+        "parse_state.pos = nlookahead_pos\n"
+    }
+    | matchExprRepeat:x matchAssign:y -> { x y }
+    ;
+
+matchAssign =
+    | ':' name:x -> { "append_named_action(variables, '" x "', _)\n" }
+    |            -> {}
+    ;
+
+matchExprRepeat =
+    | matchExprPrimitive:x '*' -> {
+        "star_variables = create_variables()\n"
+        "star_start_pos = parse_state.pos\n"
+        "while True:\n" >
+            "star_pos = parse_state.pos\n"
+            x
+            "if _ == ERROR:\n" >
+                "parse_state.pos = star_pos\n"
+                "break\n"
+            <
+            "append_named_action(star_variables, None, _)\n"
+        <
+        "_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
+    }
+    | matchExprPrimitive:x -> {
+        x
+    }
+    ;
+
+matchExprPrimitive =
+    | name:x       -> {
+        "_ = rule_" x "(parse_state)\n"
+    }
+    | '.'          -> {
+        "if parse_state.pos != len(parse_state.input_buffer):\n" >
+            "parse_state.pos += 1\n"
+            "_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n"
+        <
+        "else:\n" >
+            "_ = ERROR\n"
+        <
+    }
+    | charstring:x -> {
+        "data = b" x "\n"
+        "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n" >
+            "parse_state.pos += len(data)\n"
+            "_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n"
+        <
+        "else:\n" >
+            "_ = ERROR\n"
+        <
+    }
+    ;
+
+action =
+    | space '->' space '{' actionexpr*:xs space '}' -> {
+        #inc(W[0] 1)
+        >actions {
+            "def action_" W[0] "(runtime, variables):\n" >
+                "pass\n"
+                xs
+            <
+            "\n"
+        }
+        "return create_action(action_" W[0] ", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+    }
+    | -> {
+        "return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+    }
+    ;
+
+actionexpr =
+    | space 'unseen(' name:x ') -> {' actionexpr*:ys space '}' -> {
+        "action = lookup_action(variables, '" x "')\n"
+        "if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):\n" >
+            "pass\n"
+            ys
+        <
+    }
+    | space '>' chunkName:x space '{' actionexpr*:ys space '}' -> {
+        "last_chunks = runtime.current_chunks\n"
+        "chunks = runtime.named_chunks_" x "\n"
+        "runtime.current_chunks = chunks\n"
+        ys
+        "runtime.current_chunks = last_chunks\n"
+    }
+    | space '<' chunkName:x -> {
+        "chunks = create_chunks()\n"
+        "runtime.named_chunks_" x " = chunks\n"
+        "append_data(runtime.current_chunks, b'', 0, chunks)\n"
+    }
+    | space expr:x -> {
+        "append_data(runtime.current_chunks, str(" x ").encode('ascii'), 0)\n"
+    }
+    | space name:x -> {
+        "run_action(lookup_action(variables, '" x "'), runtime)\n"
+    }
+    | space placeholder:x -> {
+        #inc(W[1] 1)
+        >placeholders {
+            "def placeholder_" W[1] "(runtime, variables):\n" >
+                "pass\n"
+                x
+            <
+            "\n"
+        }
+        "chunks = create_chunks()\n"
+        "append_placeholder(runtime.placeholders, chunks, create_action(placeholder_" W[1] ", variables, '', 0, 0))\n"
+        "append_data(runtime.current_chunks, b'', 0, chunks)\n"
+    }
+    | space string:x -> {
+        "append_data(runtime.current_chunks, b" x ", 0)\n"
+    }
+    | space '#' name:x '(' wvar:y ' ' actionPrimitiveExpression:z ')' -> {
+        "runtime.W_" y " = " x "(runtime.W_" y " or 0, " z ")\n"
+    }
+    | space '>' actionexpr*:xs space '<' -> {
+        "append_data(runtime.current_chunks, b'', 1)\n"
+        xs
+        "append_data(runtime.current_chunks, b'', -1)\n"
+    }
+    ;
+
+chunkName = name:x -> {
+    >namedChunks {
+        unseen(x) -> {
+            "named_chunks_" x " = None\n"
+        }
+    }
+    x
+};
+
+actionPrimitiveExpression =
+    | dotname:x -> { x }
+    | digit
+    ;
+
+digit =
+    | '0'
+    | '1'
+    | '2'
+    | '3'
+    | '4'
+    | '5'
+    | '6'
+    | '7'
+    | '8'
+    | '9'
+    ;
+
+placeholder
+    = '{' space string:x '*' expr:y space '}' -> {
+        "append_data(runtime.current_chunks, b" x "*" y ", 0)\n"
+    }
+    ;
+
+expr =
+    | wvar:x -> {
+        "(runtime.W_" x " or 0)"
+    }
+    | '(' wvar:x '-' dotname:y ')' -> {
+        "((runtime.W_" x " or 0)-"  y ")"
+    }
+    ;
+
+string = '"' stringinner* '"';
+
+dotname = name:x nextname*:xs -> {
+    "lookup_action(variables, '" x "')" xs
+};
+
+nextname = '.' name;
+
+wvar = 'W[' .:x ']' -> {
+    >namedWs {
+        unseen(x) -> {
+            "W_" x " = None\n"
+        }
+    }
+    x
+};
+
+stringinner = !stringend .;
+
+stringend = '"';
+
+charstring = quote innercharstring* quote;
+
+quote = '\'';
+
+innercharstring = '\\\'' -> {"'"} | !quote .;
+
+name = char char*;
+
+char =
+    |'a'|'b'|'c'|'d'|'e'|'f'|'g'|'h'|'i'|'j'|'k'|'l'|'m'|'n'|'o'|'p'|'q'|'r'|'s'|'t'|'u'|'v'|'w'|'x'|'y'|'z'
+    |'A'|'B'|'C'|'D'|'E'|'F'|'G'|'H'|'I'|'J'|'K'|'L'|'M'|'N'|'O'|'P'|'Q'|'R'|'S'|'T'|'U'|'V'|'W'|'X'|'Y'|'Z'
+    ;
+
+space = spacechar*;
+
+spacechar = ' ' | '\n';
diff --git a/08_translate_to_c/table.rlmeta2 b/08_translate_to_c/table.rlmeta2
new file mode 100644
index 0000000..db13e52
--- /dev/null
+++ b/08_translate_to_c/table.rlmeta2
@@ -0,0 +1,24 @@
+main = table:x -> { x };
+table = row:x row*:xs !any -> {
+            x
+            { "-"*W[0] }
+            "  "
+            { "-"*W[1] }
+            "\n"
+            xs
+        };
+row   = value:x ',' value:y '\n' -> {
+            #max(W[0] x.len)
+            #max(W[1] y.len)
+            x
+            {
+                " "*(W[0]-x.len)
+            }
+            "  "
+            y
+            "\n"
+        };
+value = cellpart*;
+cellpart = !cellboundry .;
+cellboundry = ',' | '\n';
+any = .;
diff --git a/08_translate_to_c/table.txt b/08_translate_to_c/table.txt
new file mode 100644
index 0000000..fa5b8a8
--- /dev/null
+++ b/08_translate_to_c/table.txt
@@ -0,0 +1,3 @@
+Name,Age
+Rickard,40
+Axel,7
diff --git a/08_translate_to_c/test.sh b/08_translate_to_c/test.sh
new file mode 100755
index 0000000..b5fce01
--- /dev/null
+++ b/08_translate_to_c/test.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+set -e
+
+cd "$(dirname "$0")"
+
+echo "Compiling rlmeta2_meta.py"
+python rlmeta2.py <rlmeta2.rlmeta2 >rlmeta2_meta.py
+
+echo "Is metacompiler? Diff rlmeta2_meta.py"
+diff rlmeta2.py rlmeta2_meta.py
+
+echo "Compiling table.py"
+python rlmeta2.py <table.rlmeta2 >table.py
+
+echo "Diffing"
+if diff <(python table.py < table.txt) <(cat <<EOF
+Name     Age
+-------  ---
+Rickard  40
+Axel     7
+EOF
+); then
+    echo Diff OK
+fi
+
+python table.py < table.txt

2025-10-31 08:25 Rickard pushed to rlmeta2

commit d5e5800ef69cfb51213221748b405de2dea7071a
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 08:22:22 2025 +0100

    Simpler/more clever implementation of unseen

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 2cf4fe9..71d6dde 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -37,10 +37,6 @@ class Chunks:
     last = None
     seen = None
 
-class SeenData:
-    next = None
-    data = None
-
 class Chunk:
     next = None
     data = None
@@ -119,15 +115,11 @@ def append_data(chunks, data, indentation_delta, sub_chunks=None):
     chunks.last = chunk
 
 def seen(chunks, data):
-    seen_data = chunks.seen
-    while seen_data:
-        if seen_data.data == data:
+    chunk = chunks.pre_first.next
+    while chunk:
+        if chunk.data == data:
             return True
-        seen_data = seen_data.next
-    seen = SeenData()
-    seen.next = chunks.seen
-    seen.data = data
-    chunks.seen = seen
+        chunk = chunk.next
     return False
 
 def append_named_action(variables, name, action):
@@ -231,12 +223,6 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunks, b"seen = None\n", 0)
     append_data(runtime.current_chunks, b'', -1)
     append_data(runtime.current_chunks, b"\n", 0)
-    append_data(runtime.current_chunks, b"class SeenData:\n", 0)
-    append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"next = None\n", 0)
-    append_data(runtime.current_chunks, b"data = None\n", 0)
-    append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"\n", 0)
     append_data(runtime.current_chunks, b"class Chunk:\n", 0)
     append_data(runtime.current_chunks, b'', 1)
     append_data(runtime.current_chunks, b"next = None\n", 0)
@@ -348,19 +334,15 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunks, b"\n", 0)
     append_data(runtime.current_chunks, b"def seen(chunks, data):\n", 0)
     append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"seen_data = chunks.seen\n", 0)
-    append_data(runtime.current_chunks, b"while seen_data:\n", 0)
+    append_data(runtime.current_chunks, b"chunk = chunks.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while chunk:\n", 0)
     append_data(runtime.current_chunks, b'', 1)
-    append_data(runtime.current_chunks, b"if seen_data.data == data:\n", 0)
+    append_data(runtime.current_chunks, b"if chunk.data == data:\n", 0)
     append_data(runtime.current_chunks, b'', 1)
     append_data(runtime.current_chunks, b"return True\n", 0)
     append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"seen_data = seen_data.next\n", 0)
+    append_data(runtime.current_chunks, b"chunk = chunk.next\n", 0)
     append_data(runtime.current_chunks, b'', -1)
-    append_data(runtime.current_chunks, b"seen = SeenData()\n", 0)
-    append_data(runtime.current_chunks, b"seen.next = chunks.seen\n", 0)
-    append_data(runtime.current_chunks, b"seen.data = data\n", 0)
-    append_data(runtime.current_chunks, b"chunks.seen = seen\n", 0)
     append_data(runtime.current_chunks, b"return False\n", 0)
     append_data(runtime.current_chunks, b'', -1)
     append_data(runtime.current_chunks, b"\n", 0)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 98210b5..64c0e64 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -42,11 +42,6 @@ file = rule*:xs space !. -> {
         "seen = None\n"
     <
     "\n"
-    "class SeenData:\n" >
-        "next = None\n"
-        "data = None\n"
-    <
-    "\n"
     "class Chunk:\n" >
         "next = None\n"
         "data = None\n"
@@ -141,17 +136,13 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "def seen(chunks, data):\n" >
-        "seen_data = chunks.seen\n"
-        "while seen_data:\n" >
-            "if seen_data.data == data:\n" >
+        "chunk = chunks.pre_first.next\n"
+        "while chunk:\n" >
+            "if chunk.data == data:\n" >
                 "return True\n"
             <
-            "seen_data = seen_data.next\n"
+            "chunk = chunk.next\n"
         <
-        "seen = SeenData()\n"
-        "seen.next = chunks.seen\n"
-        "seen.data = data\n"
-        "chunks.seen = seen\n"
         "return False\n"
     <
     "\n"

commit 6f725fbbda48a3b30d76fd93d93befacfd64525b
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 08:09:46 2025 +0100

    Clean up various things (forgot to commit at good place)

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index ff464ed..2cf4fe9 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -5,13 +5,14 @@ class ParseState:
     pos = None
 
 class Runtime:
-    output_chunk_buffer = None
-    current_chunk_buffer = None
+    main_chunks = None
+    named_chunks_namedChunks = None
+    named_chunks_namedWs = None
+    named_chunks_actions = None
+    named_chunks_placeholders = None
+    current_chunks = None
     W_0 = None
-    action_chunk_buffer = None
-    namedBuffers_chunk_buffer = None
     W_1 = None
-    placeholder_chunk_buffer = None
     placeholders = None
 
 class Action:
@@ -31,7 +32,7 @@ class Variable:
     name = None
     action = None
 
-class ChunkBuffer:
+class Chunks:
     pre_first = None
     last = None
     seen = None
@@ -43,7 +44,7 @@ class SeenData:
 class Chunk:
     next = None
     data = None
-    chunk_buffer = None
+    chunks = None
     indentation_delta = None
 
 class Placeholders:
@@ -52,7 +53,7 @@ class Placeholders:
 
 class Placeholder:
     next = None
-    chunk_buffer = None
+    chunks = None
     action = None
 
 def create_parse_state_from_stdin():
@@ -63,8 +64,8 @@ def create_parse_state_from_stdin():
 
 def create_runtime():
     runtime = Runtime()
-    runtime.output_chunk_buffer = create_chunk_buffer()
-    runtime.current_chunk_buffer = runtime.output_chunk_buffer
+    runtime.main_chunks = create_chunks()
+    runtime.current_chunks = runtime.main_chunks
     runtime.placeholders = create_placeholders()
     return runtime
 
@@ -84,11 +85,11 @@ def create_variables():
     variables.last = variables.pre_first
     return variables
 
-def create_chunk_buffer():
-    chunk_buffer = ChunkBuffer()
-    chunk_buffer.pre_first = Chunk()
-    chunk_buffer.last = chunk_buffer.pre_first
-    return chunk_buffer
+def create_chunks():
+    chunks = Chunks()
+    chunks.pre_first = Chunk()
+    chunks.last = chunks.pre_first
+    return chunks
 
 def create_placeholders():
     placeholders = Placeholder()
@@ -99,7 +100,7 @@ def create_placeholders():
 def run_action(action, runtime):
     if action.function is None:
         if action.variables is None:
-            append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)
+            append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)
         else:
             variable = action.variables.pre_first.next
             while variable:
@@ -108,25 +109,25 @@ def run_action(action, runtime):
     else:
         action.function(runtime, action.variables)
 
-def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):
+def append_data(chunks, data, indentation_delta, sub_chunks=None):
     chunk = Chunk()
     chunk.next = None
     chunk.data = data
-    chunk.chunk_buffer = sub_chunk_buffer
+    chunk.chunks = sub_chunks
     chunk.indentation_delta = indentation_delta
-    chunk_buffer.last.next = chunk
-    chunk_buffer.last = chunk
+    chunks.last.next = chunk
+    chunks.last = chunk
 
-def seen(chunk_buffer, data):
-    seen_data = chunk_buffer.seen
+def seen(chunks, data):
+    seen_data = chunks.seen
     while seen_data:
         if seen_data.data == data:
             return True
         seen_data = seen_data.next
     seen = SeenData()
-    seen.next = chunk_buffer.seen
+    seen.next = chunks.seen
     seen.data = data
-    chunk_buffer.seen = seen
+    chunks.seen = seen
     return False
 
 def append_named_action(variables, name, action):
@@ -146,10 +147,10 @@ def lookup_action(variables, name_to_look_for):
             variable = variable.next
     raise ValueError(f'variable {name_to_look_for} not found')
 
-def append_placeholder(placeholders, chunk_buffer, action):
+def append_placeholder(placeholders, chunks, action):
     next_variable = Placeholder()
     next_variable.next = None
-    next_variable.chunk_buffer = chunk_buffer
+    next_variable.chunks = chunks
     next_variable.action = action
     placeholders.last.next = next_variable
     placeholders.last = next_variable
@@ -157,9 +158,9 @@ def append_placeholder(placeholders, chunk_buffer, action):
 def inc(value, amount):
     return value + amount
 
-def render_chunk_buffer(chunk_buffer, last_char=b'\n', indent=0):
-    if chunk_buffer:
-        chunk = chunk_buffer.pre_first.next
+def render_chunks(chunks, last_char=b'\n', indent=0):
+    if chunks:
+        chunk = chunks.pre_first.next
         while chunk:
             indent += chunk.indentation_delta
             for char in chunk.data:
@@ -167,7 +168,7 @@ def render_chunk_buffer(chunk_buffer, last_char=b'\n', indent=0):
                     sys.stdout.buffer.write(b'    '*indent)
                 last_char = char.to_bytes()
                 sys.stdout.buffer.write(last_char)
-            last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)
+            last_char, indent = render_chunks(chunk.chunks, last_char, indent)
             chunk = chunk.next
     return last_char, indent
 
@@ -179,298 +180,301 @@ def action_1(runtime, variables):
 
 def action_2(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"import sys\n", 0)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class ParseState:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"input_buffer = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"pos = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Runtime:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"output_chunk_buffer = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"current_chunk_buffer = None\n", 0)
-    chunk_buffer = create_chunk_buffer()
-    runtime.namedBuffers_chunk_buffer = chunk_buffer
-    append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
-    append_data(runtime.current_chunk_buffer, b"placeholders = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Action:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"function = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"input_buffer = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"start = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"end = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"len = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Variables:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Variable:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"name = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class ChunkBuffer:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"seen = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class SeenData:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"data = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Chunk:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"data = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"indentation_delta = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Placeholders:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Placeholder:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_parse_state_from_stdin():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"parse_state = ParseState()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"parse_state.input_buffer = sys.stdin.buffer.read()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"parse_state.pos = 0\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return parse_state\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_runtime():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"runtime = Runtime()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.output_chunk_buffer = create_chunk_buffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = runtime.output_chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.placeholders = create_placeholders()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return runtime\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_action(function, variables, input_buffer, start, end):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"action = Action()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action.function = function\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action.variables = variables\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action.input_buffer = input_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action.start = start\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action.end = end\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action.len = end-start\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return action\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_variables():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"variables = Variables()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables.pre_first = Variable()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables.last = variables.pre_first\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return variables\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_chunk_buffer():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = ChunkBuffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer.pre_first = Chunk()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk_buffer.pre_first\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_placeholders():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"placeholders = Placeholder()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"placeholders.pre_first = Placeholder()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"placeholders.last = placeholders.pre_first\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return placeholders\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def run_action(action, runtime):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"if action.function is None:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"if action.variables is None:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"variable = action.variables.pre_first.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b"while variable:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"run_action(variable.action, runtime)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variable = variable.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"action.function(runtime, action.variables)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"chunk = Chunk()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk.next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk.data = data\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk.chunk_buffer = sub_chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk.indentation_delta = indentation_delta\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last.next = chunk\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def seen(chunk_buffer, data):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"seen_data = chunk_buffer.seen\n", 0)
-    append_data(runtime.current_chunk_buffer, b"while seen_data:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"if seen_data.data == data:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"return True\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"seen_data = seen_data.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"seen = SeenData()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"seen.next = chunk_buffer.seen\n", 0)
-    append_data(runtime.current_chunk_buffer, b"seen.data = data\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer.seen = seen\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return False\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def append_named_action(variables, name, action):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"next_variable = Variable()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.name = name\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.action = action\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables.last.next = next_variable\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables.last = next_variable\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def lookup_action(variables, name_to_look_for):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"variable = variables.pre_first.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b"while variable:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"if variable.name == name_to_look_for:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"return variable.action\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"variable = variable.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def append_placeholder(placeholders, chunk_buffer, action):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"next_variable = Placeholder()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.chunk_buffer = chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.action = action\n", 0)
-    append_data(runtime.current_chunk_buffer, b"placeholders.last.next = next_variable\n", 0)
-    append_data(runtime.current_chunk_buffer, b"placeholders.last = next_variable\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def inc(value, amount):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"return value + amount\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def render_chunk_buffer(chunk_buffer, last_char=b'\\n', indent=0):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"if chunk_buffer:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"chunk = chunk_buffer.pre_first.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b"while chunk:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"indent += chunk.indentation_delta\n", 0)
-    append_data(runtime.current_chunk_buffer, b"for char in chunk.data:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"if last_char == b'\\n':\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"sys.stdout.buffer.write(b'    '*indent)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"last_char = char.to_bytes()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"sys.stdout.buffer.write(last_char)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk = chunk.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"return last_char, indent\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"ERROR = -1\n", 0)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    chunk_buffer = create_chunk_buffer()
-    runtime.action_chunk_buffer = chunk_buffer
-    append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
-    chunk_buffer = create_chunk_buffer()
-    runtime.placeholder_chunk_buffer = chunk_buffer
-    append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
+    append_data(runtime.current_chunks, b"import sys\n", 0)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class ParseState:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"input_buffer = None\n", 0)
+    append_data(runtime.current_chunks, b"pos = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Runtime:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"main_chunks = None\n", 0)
+    chunks = create_chunks()
+    runtime.named_chunks_namedChunks = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
+    append_data(runtime.current_chunks, b"current_chunks = None\n", 0)
+    chunks = create_chunks()
+    runtime.named_chunks_namedWs = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
+    append_data(runtime.current_chunks, b"placeholders = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Action:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"function = None\n", 0)
+    append_data(runtime.current_chunks, b"variables = None\n", 0)
+    append_data(runtime.current_chunks, b"input_buffer = None\n", 0)
+    append_data(runtime.current_chunks, b"start = None\n", 0)
+    append_data(runtime.current_chunks, b"end = None\n", 0)
+    append_data(runtime.current_chunks, b"len = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Variables:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunks, b"last = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Variable:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next = None\n", 0)
+    append_data(runtime.current_chunks, b"name = None\n", 0)
+    append_data(runtime.current_chunks, b"action = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Chunks:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunks, b"last = None\n", 0)
+    append_data(runtime.current_chunks, b"seen = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class SeenData:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next = None\n", 0)
+    append_data(runtime.current_chunks, b"data = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Chunk:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next = None\n", 0)
+    append_data(runtime.current_chunks, b"data = None\n", 0)
+    append_data(runtime.current_chunks, b"chunks = None\n", 0)
+    append_data(runtime.current_chunks, b"indentation_delta = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Placeholders:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunks, b"last = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"class Placeholder:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next = None\n", 0)
+    append_data(runtime.current_chunks, b"chunks = None\n", 0)
+    append_data(runtime.current_chunks, b"action = None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_parse_state_from_stdin():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state = ParseState()\n", 0)
+    append_data(runtime.current_chunks, b"parse_state.input_buffer = sys.stdin.buffer.read()\n", 0)
+    append_data(runtime.current_chunks, b"parse_state.pos = 0\n", 0)
+    append_data(runtime.current_chunks, b"return parse_state\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_runtime():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"runtime = Runtime()\n", 0)
+    append_data(runtime.current_chunks, b"runtime.main_chunks = create_chunks()\n", 0)
+    append_data(runtime.current_chunks, b"runtime.current_chunks = runtime.main_chunks\n", 0)
+    append_data(runtime.current_chunks, b"runtime.placeholders = create_placeholders()\n", 0)
+    append_data(runtime.current_chunks, b"return runtime\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_action(function, variables, input_buffer, start, end):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"action = Action()\n", 0)
+    append_data(runtime.current_chunks, b"action.function = function\n", 0)
+    append_data(runtime.current_chunks, b"action.variables = variables\n", 0)
+    append_data(runtime.current_chunks, b"action.input_buffer = input_buffer\n", 0)
+    append_data(runtime.current_chunks, b"action.start = start\n", 0)
+    append_data(runtime.current_chunks, b"action.end = end\n", 0)
+    append_data(runtime.current_chunks, b"action.len = end-start\n", 0)
+    append_data(runtime.current_chunks, b"return action\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_variables():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variables = Variables()\n", 0)
+    append_data(runtime.current_chunks, b"variables.pre_first = Variable()\n", 0)
+    append_data(runtime.current_chunks, b"variables.last = variables.pre_first\n", 0)
+    append_data(runtime.current_chunks, b"return variables\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_chunks():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"chunks = Chunks()\n", 0)
+    append_data(runtime.current_chunks, b"chunks.pre_first = Chunk()\n", 0)
+    append_data(runtime.current_chunks, b"chunks.last = chunks.pre_first\n", 0)
+    append_data(runtime.current_chunks, b"return chunks\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def create_placeholders():\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"placeholders = Placeholder()\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.pre_first = Placeholder()\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.last = placeholders.pre_first\n", 0)
+    append_data(runtime.current_chunks, b"return placeholders\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def run_action(action, runtime):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if action.function is None:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if action.variables is None:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variable = action.variables.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while variable:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"run_action(variable.action, runtime)\n", 0)
+    append_data(runtime.current_chunks, b"variable = variable.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"action.function(runtime, action.variables)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def append_data(chunks, data, indentation_delta, sub_chunks=None):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"chunk = Chunk()\n", 0)
+    append_data(runtime.current_chunks, b"chunk.next = None\n", 0)
+    append_data(runtime.current_chunks, b"chunk.data = data\n", 0)
+    append_data(runtime.current_chunks, b"chunk.chunks = sub_chunks\n", 0)
+    append_data(runtime.current_chunks, b"chunk.indentation_delta = indentation_delta\n", 0)
+    append_data(runtime.current_chunks, b"chunks.last.next = chunk\n", 0)
+    append_data(runtime.current_chunks, b"chunks.last = chunk\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def seen(chunks, data):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"seen_data = chunks.seen\n", 0)
+    append_data(runtime.current_chunks, b"while seen_data:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if seen_data.data == data:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"return True\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"seen_data = seen_data.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"seen = SeenData()\n", 0)
+    append_data(runtime.current_chunks, b"seen.next = chunks.seen\n", 0)
+    append_data(runtime.current_chunks, b"seen.data = data\n", 0)
+    append_data(runtime.current_chunks, b"chunks.seen = seen\n", 0)
+    append_data(runtime.current_chunks, b"return False\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def append_named_action(variables, name, action):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next_variable = Variable()\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.next = None\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.name = name\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.action = action\n", 0)
+    append_data(runtime.current_chunks, b"variables.last.next = next_variable\n", 0)
+    append_data(runtime.current_chunks, b"variables.last = next_variable\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def lookup_action(variables, name_to_look_for):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variable = variables.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while variable:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if variable.name == name_to_look_for:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"return variable.action\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"variable = variable.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def append_placeholder(placeholders, chunks, action):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"next_variable = Placeholder()\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.next = None\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.chunks = chunks\n", 0)
+    append_data(runtime.current_chunks, b"next_variable.action = action\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.last.next = next_variable\n", 0)
+    append_data(runtime.current_chunks, b"placeholders.last = next_variable\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def inc(value, amount):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"return value + amount\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"def render_chunks(chunks, last_char=b'\\n', indent=0):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if chunks:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"chunk = chunks.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while chunk:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"indent += chunk.indentation_delta\n", 0)
+    append_data(runtime.current_chunks, b"for char in chunk.data:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"if last_char == b'\\n':\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"sys.stdout.buffer.write(b'    '*indent)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"last_char = char.to_bytes()\n", 0)
+    append_data(runtime.current_chunks, b"sys.stdout.buffer.write(last_char)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"last_char, indent = render_chunks(chunk.chunks, last_char, indent)\n", 0)
+    append_data(runtime.current_chunks, b"chunk = chunk.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"return last_char, indent\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"ERROR = -1\n", 0)
+    append_data(runtime.current_chunks, b"\n", 0)
+    chunks = create_chunks()
+    runtime.named_chunks_actions = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
+    chunks = create_chunks()
+    runtime.named_chunks_placeholders = chunks
+    append_data(runtime.current_chunks, b'', 0, chunks)
     run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunk_buffer, b"if __name__ == '__main__':\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"parse_state = create_parse_state_from_stdin()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime = create_runtime()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action = rule_main(parse_state)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"if action == ERROR:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"sys.exit('Parse error')\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"run_action(action, runtime)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"placeholder = runtime.placeholders.pre_first.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b"while placeholder:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = placeholder.chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"run_action(placeholder.action, runtime)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"placeholder = placeholder.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunks, b"if __name__ == '__main__':\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state = create_parse_state_from_stdin()\n", 0)
+    append_data(runtime.current_chunks, b"runtime = create_runtime()\n", 0)
+    append_data(runtime.current_chunks, b"action = rule_main(parse_state)\n", 0)
+    append_data(runtime.current_chunks, b"if action == ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"sys.exit('Parse error')\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"run_action(action, runtime)\n", 0)
+    append_data(runtime.current_chunks, b"placeholder = runtime.placeholders.pre_first.next\n", 0)
+    append_data(runtime.current_chunks, b"while placeholder:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"runtime.current_chunks = placeholder.chunks\n", 0)
+    append_data(runtime.current_chunks, b"run_action(placeholder.action, runtime)\n", 0)
+    append_data(runtime.current_chunks, b"placeholder = placeholder.next\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"render_chunks(runtime.main_chunks)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
 
 def action_3(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"def rule_", 0)
+    append_data(runtime.current_chunks, b"def rule_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"(parse_state):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunks, b"(parse_state):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
     run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
 
 def action_4(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"or_backtrack_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunks, b"or_backtrack_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variables, 'x'), runtime)
     run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunk_buffer, b"return ERROR\n", 0)
+    append_data(runtime.current_chunks, b"return ERROR\n", 0)
 
 def action_5(runtime, variables):
     pass
@@ -481,18 +485,18 @@ def action_6(runtime, variables):
 
 def action_7(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"parse_state.pos = or_backtrack_pos\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action_start_pos = parse_state.pos\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables = create_variables()\n", 0)
+    append_data(runtime.current_chunks, b"parse_state.pos = or_backtrack_pos\n", 0)
+    append_data(runtime.current_chunks, b"action_start_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunks, b"variables = create_variables()\n", 0)
     run_action(lookup_action(variables, 'x'), runtime)
 
 def action_8(runtime, variables):
     pass
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"if _ != ERROR:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunks, b"if _ != ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
     run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
 
 def action_9(runtime, variables):
     pass
@@ -500,17 +504,17 @@ def action_9(runtime, variables):
 
 def action_10(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"nlookahead_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunks, b"nlookahead_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"if _ == ERROR:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"_ = lambda: None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"parse_state.pos = nlookahead_pos\n", 0)
+    append_data(runtime.current_chunks, b"if _ == ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = lambda: None\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"parse_state.pos = nlookahead_pos\n", 0)
 
 def action_11(runtime, variables):
     pass
@@ -519,29 +523,29 @@ def action_11(runtime, variables):
 
 def action_12(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"append_named_action(variables, '", 0)
+    append_data(runtime.current_chunks, b"append_named_action(variables, '", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"', _)\n", 0)
+    append_data(runtime.current_chunks, b"', _)\n", 0)
 
 def action_13(runtime, variables):
     pass
 
 def action_14(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"star_variables = create_variables()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"star_start_pos = parse_state.pos\n", 0)
-    append_data(runtime.current_chunk_buffer, b"while True:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"star_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunks, b"star_variables = create_variables()\n", 0)
+    append_data(runtime.current_chunks, b"star_start_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunks, b"while True:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"star_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"if _ == ERROR:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"parse_state.pos = star_pos\n", 0)
-    append_data(runtime.current_chunk_buffer, b"break\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"append_named_action(star_variables, None, _)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunks, b"if _ == ERROR:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state.pos = star_pos\n", 0)
+    append_data(runtime.current_chunks, b"break\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"append_named_action(star_variables, None, _)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variables):
     pass
@@ -549,202 +553,210 @@ def action_15(runtime, variables):
 
 def action_16(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"_ = rule_", 0)
+    append_data(runtime.current_chunks, b"_ = rule_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"(parse_state)\n", 0)
+    append_data(runtime.current_chunks, b"(parse_state)\n", 0)
 
 def action_17(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"parse_state.pos += 1\n", 0)
-    append_data(runtime.current_chunk_buffer, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunks, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state.pos += 1\n", 0)
+    append_data(runtime.current_chunks, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
 
 def action_18(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"data = b", 0)
+    append_data(runtime.current_chunks, b"data = b", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"parse_state.pos += len(data)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"parse_state.pos += len(data)\n", 0)
+    append_data(runtime.current_chunks, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"else:\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
 
 def action_19(runtime, variables):
     pass
     runtime.W_0 = inc(runtime.W_0 or 0, 1)
-    last_chunk_buffer = runtime.current_chunk_buffer
-    chunk_buffer = runtime.action_chunk_buffer
-    runtime.current_chunk_buffer = chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"def action_", 0)
-    append_data(runtime.current_chunk_buffer, str((runtime.W_0 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b"(runtime, variables):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"pass\n", 0)
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_actions
+    runtime.current_chunks = chunks
+    append_data(runtime.current_chunks, b"def action_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_0 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b"(runtime, variables):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pass\n", 0)
     run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    runtime.current_chunk_buffer = last_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"return create_action(action_", 0)
-    append_data(runtime.current_chunk_buffer, str((runtime.W_0 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    runtime.current_chunks = last_chunks
+    append_data(runtime.current_chunks, b"return create_action(action_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_0 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunks, b"return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_21(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"action = lookup_action(variables, '", 0)
+    append_data(runtime.current_chunks, b"action = lookup_action(variables, '", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"')\n", 0)
-    append_data(runtime.current_chunk_buffer, b"if not seen(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end]):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"pass\n", 0)
+    append_data(runtime.current_chunks, b"')\n", 0)
+    append_data(runtime.current_chunks, b"if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pass\n", 0)
     run_action(lookup_action(variables, 'ys'), runtime)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunks, b'', -1)
 
 def action_22(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = runtime.", 0)
+    append_data(runtime.current_chunks, b"last_chunks = runtime.current_chunks\n", 0)
+    append_data(runtime.current_chunks, b"chunks = runtime.named_chunks_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"_chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
+    append_data(runtime.current_chunks, b"\n", 0)
+    append_data(runtime.current_chunks, b"runtime.current_chunks = chunks\n", 0)
     run_action(lookup_action(variables, 'ys'), runtime)
-    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = last_chunk_buffer\n", 0)
-    last_chunk_buffer = runtime.current_chunk_buffer
-    chunk_buffer = runtime.namedBuffers_chunk_buffer
-    runtime.current_chunk_buffer = chunk_buffer
-    action = lookup_action(variables, 'x')
-    if not seen(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end]):
-        pass
-        run_action(lookup_action(variables, 'x'), runtime)
-        append_data(runtime.current_chunk_buffer, b"_chunk_buffer = None\n", 0)
-    runtime.current_chunk_buffer = last_chunk_buffer
+    append_data(runtime.current_chunks, b"runtime.current_chunks = last_chunks\n", 0)
 
 def action_23(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.", 0)
+    append_data(runtime.current_chunks, b"chunks = create_chunks()\n", 0)
+    append_data(runtime.current_chunks, b"runtime.named_chunks_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"_chunk_buffer = chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
+    append_data(runtime.current_chunks, b" = chunks\n", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 0, chunks)\n", 0)
 
 def action_24(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, str(", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, str(", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b").encode('ascii'), 0)\n", 0)
+    append_data(runtime.current_chunks, b").encode('ascii'), 0)\n", 0)
 
 def action_25(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"run_action(lookup_action(variables, '", 0)
+    append_data(runtime.current_chunks, b"run_action(lookup_action(variables, '", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"'), runtime)\n", 0)
+    append_data(runtime.current_chunks, b"'), runtime)\n", 0)
 
 def action_26(runtime, variables):
     pass
     runtime.W_1 = inc(runtime.W_1 or 0, 1)
-    last_chunk_buffer = runtime.current_chunk_buffer
-    chunk_buffer = runtime.placeholder_chunk_buffer
-    runtime.current_chunk_buffer = chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"def placeholder_", 0)
-    append_data(runtime.current_chunk_buffer, str((runtime.W_1 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b"(runtime, variables):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"pass\n", 0)
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_placeholders
+    runtime.current_chunks = chunks
+    append_data(runtime.current_chunks, b"def placeholder_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_1 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b"(runtime, variables):\n", 0)
+    append_data(runtime.current_chunks, b'', 1)
+    append_data(runtime.current_chunks, b"pass\n", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    runtime.current_chunk_buffer = last_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"append_placeholder(runtime.placeholders, chunk_buffer, create_action(placeholder_", 0)
-    append_data(runtime.current_chunk_buffer, str((runtime.W_1 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b", variables, '', 0, 0))\n", 0)
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
+    append_data(runtime.current_chunks, b'', -1)
+    append_data(runtime.current_chunks, b"\n", 0)
+    runtime.current_chunks = last_chunks
+    append_data(runtime.current_chunks, b"chunks = create_chunks()\n", 0)
+    append_data(runtime.current_chunks, b"append_placeholder(runtime.placeholders, chunks, create_action(placeholder_", 0)
+    append_data(runtime.current_chunks, str((runtime.W_1 or 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunks, b", variables, '', 0, 0))\n", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 0, chunks)\n", 0)
 
 def action_27(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
+    append_data(runtime.current_chunks, b", 0)\n", 0)
 
 def action_28(runtime, variables):
     pass
-    last_chunk_buffer = runtime.current_chunk_buffer
-    chunk_buffer = runtime.namedBuffers_chunk_buffer
-    runtime.current_chunk_buffer = chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"W_", 0)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b" = None\n", 0)
-    runtime.current_chunk_buffer = last_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"runtime.W_", 0)
+    append_data(runtime.current_chunks, b"runtime.W_", 0)
     run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b" = ", 0)
+    append_data(runtime.current_chunks, b" = ", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"(runtime.W_", 0)
+    append_data(runtime.current_chunks, b"(runtime.W_", 0)
     run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b" or 0, ", 0)
+    append_data(runtime.current_chunks, b" or 0, ", 0)
     run_action(lookup_action(variables, 'z'), runtime)
-    append_data(runtime.current_chunk_buffer, b")\n", 0)
+    append_data(runtime.current_chunks, b")\n", 0)
 
 def action_29(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 1)\n", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', 1)\n", 0)
     run_action(lookup_action(variables, 'xs'), runtime)
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', -1)\n", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b'', -1)\n", 0)
 
 def action_30(runtime, variables):
     pass
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_namedChunks
+    runtime.current_chunks = chunks
+    action = lookup_action(variables, 'x')
+    if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):
+        pass
+        append_data(runtime.current_chunks, b"named_chunks_", 0)
+        run_action(lookup_action(variables, 'x'), runtime)
+        append_data(runtime.current_chunks, b" = None\n", 0)
+    runtime.current_chunks = last_chunks
     run_action(lookup_action(variables, 'x'), runtime)
 
 def action_31(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"*", 0)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
 
 def action_32(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"(runtime.W_", 0)
+    append_data(runtime.current_chunks, b"append_data(runtime.current_chunks, b", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b" or 0)", 0)
+    append_data(runtime.current_chunks, b"*", 0)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b", 0)\n", 0)
 
 def action_33(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"((runtime.W_", 0)
+    append_data(runtime.current_chunks, b"(runtime.W_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b" or 0)-", 0)
-    run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b")", 0)
+    append_data(runtime.current_chunks, b" or 0)", 0)
 
 def action_34(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"lookup_action(variables, '", 0)
+    append_data(runtime.current_chunks, b"((runtime.W_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"')", 0)
-    run_action(lookup_action(variables, 'xs'), runtime)
+    append_data(runtime.current_chunks, b" or 0)-", 0)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunks, b")", 0)
 
 def action_35(runtime, variables):
     pass
+    append_data(runtime.current_chunks, b"lookup_action(variables, '", 0)
     run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunks, b"')", 0)
+    run_action(lookup_action(variables, 'xs'), runtime)
 
 def action_36(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"'", 0)
+    last_chunks = runtime.current_chunks
+    chunks = runtime.named_chunks_namedWs
+    runtime.current_chunks = chunks
+    action = lookup_action(variables, 'x')
+    if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):
+        pass
+        append_data(runtime.current_chunks, b"W_", 0)
+        run_action(lookup_action(variables, 'x'), runtime)
+        append_data(runtime.current_chunks, b" = None\n", 0)
+    runtime.current_chunks = last_chunks
+    run_action(lookup_action(variables, 'x'), runtime)
+
+def action_37(runtime, variables):
+    pass
+    append_data(runtime.current_chunks, b"'", 0)
 
 def rule_main(parse_state):
     or_backtrack_pos = parse_state.pos
@@ -1143,7 +1155,7 @@ def rule_actionexpr(parse_state):
         else:
             _ = ERROR
         if _ != ERROR:
-            _ = rule_name(parse_state)
+            _ = rule_chunkName(parse_state)
             append_named_action(variables, 'x', _)
             if _ != ERROR:
                 _ = rule_space(parse_state)
@@ -1189,7 +1201,7 @@ def rule_actionexpr(parse_state):
         else:
             _ = ERROR
         if _ != ERROR:
-            _ = rule_name(parse_state)
+            _ = rule_chunkName(parse_state)
             append_named_action(variables, 'x', _)
             if _ != ERROR:
                 return create_action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
@@ -1308,6 +1320,17 @@ def rule_actionexpr(parse_state):
                         return create_action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
+def rule_chunkName(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_name(parse_state)
+    append_named_action(variables, 'x', _)
+    if _ != ERROR:
+        return create_action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return ERROR
+
 def rule_actionPrimitiveExpression(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
@@ -1316,7 +1339,7 @@ def rule_actionPrimitiveExpression(parse_state):
     _ = rule_dotname(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return create_action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1475,7 +1498,7 @@ def rule_placeholder(parse_state):
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return create_action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return create_action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_expr(parse_state):
@@ -1486,7 +1509,7 @@ def rule_expr(parse_state):
     _ = rule_wvar(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return create_action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1517,7 +1540,7 @@ def rule_expr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return create_action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return create_action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_string(parse_state):
@@ -1573,7 +1596,7 @@ def rule_dotname(parse_state):
         _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         append_named_action(variables, 'xs', _)
         if _ != ERROR:
-            return create_action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_nextname(parse_state):
@@ -1619,7 +1642,7 @@ def rule_wvar(parse_state):
             else:
                 _ = ERROR
             if _ != ERROR:
-                return create_action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_36, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringinner(parse_state):
@@ -1709,7 +1732,7 @@ def rule_innercharstring(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        return create_action(action_36, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_37, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -2381,7 +2404,7 @@ if __name__ == '__main__':
     run_action(action, runtime)
     placeholder = runtime.placeholders.pre_first.next
     while placeholder:
-        runtime.current_chunk_buffer = placeholder.chunk_buffer
+        runtime.current_chunks = placeholder.chunks
         run_action(placeholder.action, runtime)
         placeholder = placeholder.next
-    render_chunk_buffer(runtime.output_chunk_buffer)
+    render_chunks(runtime.main_chunks)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 6089d00..98210b5 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -9,9 +9,10 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "class Runtime:\n" >
-        "output_chunk_buffer = None\n"
-        "current_chunk_buffer = None\n"
-        <namedBuffers
+        "main_chunks = None\n"
+        <namedChunks
+        "current_chunks = None\n"
+        <namedWs
         "placeholders = None\n"
     <
     "\n"
@@ -35,7 +36,7 @@ file = rule*:xs space !. -> {
         "action = None\n"
     <
     "\n"
-    "class ChunkBuffer:\n" >
+    "class Chunks:\n" >
         "pre_first = None\n"
         "last = None\n"
         "seen = None\n"
@@ -49,7 +50,7 @@ file = rule*:xs space !. -> {
     "class Chunk:\n" >
         "next = None\n"
         "data = None\n"
-        "chunk_buffer = None\n"
+        "chunks = None\n"
         "indentation_delta = None\n"
     <
     "\n"
@@ -60,7 +61,7 @@ file = rule*:xs space !. -> {
     "\n"
     "class Placeholder:\n" >
         "next = None\n"
-        "chunk_buffer = None\n"
+        "chunks = None\n"
         "action = None\n"
     <
     "\n"
@@ -73,8 +74,8 @@ file = rule*:xs space !. -> {
     "\n"
     "def create_runtime():\n" >
         "runtime = Runtime()\n"
-        "runtime.output_chunk_buffer = create_chunk_buffer()\n"
-        "runtime.current_chunk_buffer = runtime.output_chunk_buffer\n"
+        "runtime.main_chunks = create_chunks()\n"
+        "runtime.current_chunks = runtime.main_chunks\n"
         "runtime.placeholders = create_placeholders()\n"
         "return runtime\n"
     <
@@ -97,11 +98,11 @@ file = rule*:xs space !. -> {
         "return variables\n"
     <
     "\n"
-    "def create_chunk_buffer():\n" >
-        "chunk_buffer = ChunkBuffer()\n"
-        "chunk_buffer.pre_first = Chunk()\n"
-        "chunk_buffer.last = chunk_buffer.pre_first\n"
-        "return chunk_buffer\n"
+    "def create_chunks():\n" >
+        "chunks = Chunks()\n"
+        "chunks.pre_first = Chunk()\n"
+        "chunks.last = chunks.pre_first\n"
+        "return chunks\n"
     <
     "\n"
     "def create_placeholders():\n" >
@@ -114,7 +115,7 @@ file = rule*:xs space !. -> {
     "def run_action(action, runtime):\n" >
         "if action.function is None:\n" >
             "if action.variables is None:\n" >
-                "append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)\n"
+                "append_data(runtime.current_chunks, action.input_buffer[action.start:action.end], 0)\n"
             <
             "else:\n" >
                 "variable = action.variables.pre_first.next\n"
@@ -129,18 +130,18 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
-    "def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n" >
+    "def append_data(chunks, data, indentation_delta, sub_chunks=None):\n" >
         "chunk = Chunk()\n"
         "chunk.next = None\n"
         "chunk.data = data\n"
-        "chunk.chunk_buffer = sub_chunk_buffer\n"
+        "chunk.chunks = sub_chunks\n"
         "chunk.indentation_delta = indentation_delta\n"
-        "chunk_buffer.last.next = chunk\n"
-        "chunk_buffer.last = chunk\n"
+        "chunks.last.next = chunk\n"
+        "chunks.last = chunk\n"
     <
     "\n"
-    "def seen(chunk_buffer, data):\n" >
-        "seen_data = chunk_buffer.seen\n"
+    "def seen(chunks, data):\n" >
+        "seen_data = chunks.seen\n"
         "while seen_data:\n" >
             "if seen_data.data == data:\n" >
                 "return True\n"
@@ -148,9 +149,9 @@ file = rule*:xs space !. -> {
             "seen_data = seen_data.next\n"
         <
         "seen = SeenData()\n"
-        "seen.next = chunk_buffer.seen\n"
+        "seen.next = chunks.seen\n"
         "seen.data = data\n"
-        "chunk_buffer.seen = seen\n"
+        "chunks.seen = seen\n"
         "return False\n"
     <
     "\n"
@@ -176,10 +177,10 @@ file = rule*:xs space !. -> {
         "raise ValueError(f'variable {name_to_look_for} not found')\n"
     <
     "\n"
-    "def append_placeholder(placeholders, chunk_buffer, action):\n" >
+    "def append_placeholder(placeholders, chunks, action):\n" >
         "next_variable = Placeholder()\n"
         "next_variable.next = None\n"
-        "next_variable.chunk_buffer = chunk_buffer\n"
+        "next_variable.chunks = chunks\n"
         "next_variable.action = action\n"
         "placeholders.last.next = next_variable\n"
         "placeholders.last = next_variable\n"
@@ -189,9 +190,9 @@ file = rule*:xs space !. -> {
         "return value + amount\n"
     <
     "\n"
-    "def render_chunk_buffer(chunk_buffer, last_char=b'\\n', indent=0):\n" >
-        "if chunk_buffer:\n" >
-            "chunk = chunk_buffer.pre_first.next\n"
+    "def render_chunks(chunks, last_char=b'\\n', indent=0):\n" >
+        "if chunks:\n" >
+            "chunk = chunks.pre_first.next\n"
             "while chunk:\n" >
                 "indent += chunk.indentation_delta\n"
                 "for char in chunk.data:\n" >
@@ -201,7 +202,7 @@ file = rule*:xs space !. -> {
                     "last_char = char.to_bytes()\n"
                     "sys.stdout.buffer.write(last_char)\n"
                 <
-                "last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n"
+                "last_char, indent = render_chunks(chunk.chunks, last_char, indent)\n"
                 "chunk = chunk.next\n"
             <
         <
@@ -210,8 +211,8 @@ file = rule*:xs space !. -> {
     "\n"
     "ERROR = -1\n"
     "\n"
-    <action
-    <placeholder
+    <actions
+    <placeholders
     xs
     "if __name__ == '__main__':\n" >
         "parse_state = create_parse_state_from_stdin()\n"
@@ -223,11 +224,11 @@ file = rule*:xs space !. -> {
         "run_action(action, runtime)\n"
         "placeholder = runtime.placeholders.pre_first.next\n"
         "while placeholder:\n" >
-            "runtime.current_chunk_buffer = placeholder.chunk_buffer\n"
+            "runtime.current_chunks = placeholder.chunks\n"
             "run_action(placeholder.action, runtime)\n"
             "placeholder = placeholder.next\n"
         <
-        "render_chunk_buffer(runtime.output_chunk_buffer)\n"
+        "render_chunks(runtime.main_chunks)\n"
     <
 };
 
@@ -336,7 +337,7 @@ matchExprPrimitive =
 action =
     | space '->' space '{' actionexpr*:xs space '}' -> {
         #inc(W[0] 1)
-        >action {
+        >actions {
             "def action_" W[0] "(runtime, variables):\n" >
                 "pass\n"
                 xs
@@ -353,63 +354,64 @@ action =
 actionexpr =
     | space 'unseen(' name:x ') -> {' actionexpr*:ys space '}' -> {
         "action = lookup_action(variables, '" x "')\n"
-        "if not seen(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end]):\n" >
+        "if not seen(runtime.current_chunks, action.input_buffer[action.start:action.end]):\n" >
             "pass\n"
             ys
         <
     }
-    | space '>' name:x space '{' actionexpr*:ys space '}' -> {
-        "last_chunk_buffer = runtime.current_chunk_buffer\n"
-        "chunk_buffer = runtime." x "_chunk_buffer\n"
-        "runtime.current_chunk_buffer = chunk_buffer\n"
+    | space '>' chunkName:x space '{' actionexpr*:ys space '}' -> {
+        "last_chunks = runtime.current_chunks\n"
+        "chunks = runtime.named_chunks_" x "\n"
+        "runtime.current_chunks = chunks\n"
         ys
-        "runtime.current_chunk_buffer = last_chunk_buffer\n"
-        >namedBuffers {
-            unseen(x) -> {
-                x "_chunk_buffer = None\n"
-            }
-        }
+        "runtime.current_chunks = last_chunks\n"
     }
-    | space '<' name:x -> {
-        "chunk_buffer = create_chunk_buffer()\n"
-        "runtime." x "_chunk_buffer = chunk_buffer\n"
-        "append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n"
+    | space '<' chunkName:x -> {
+        "chunks = create_chunks()\n"
+        "runtime.named_chunks_" x " = chunks\n"
+        "append_data(runtime.current_chunks, b'', 0, chunks)\n"
     }
     | space expr:x -> {
-        "append_data(runtime.current_chunk_buffer, str(" x ").encode('ascii'), 0)\n"
+        "append_data(runtime.current_chunks, str(" x ").encode('ascii'), 0)\n"
     }
     | space name:x -> {
         "run_action(lookup_action(variables, '" x "'), runtime)\n"
     }
     | space placeholder:x -> {
         #inc(W[1] 1)
-        >placeholder {
+        >placeholders {
             "def placeholder_" W[1] "(runtime, variables):\n" >
                 "pass\n"
                 x
             <
             "\n"
         }
-        "chunk_buffer = create_chunk_buffer()\n"
-        "append_placeholder(runtime.placeholders, chunk_buffer, create_action(placeholder_" W[1] ", variables, '', 0, 0))\n"
-        "append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n"
+        "chunks = create_chunks()\n"
+        "append_placeholder(runtime.placeholders, chunks, create_action(placeholder_" W[1] ", variables, '', 0, 0))\n"
+        "append_data(runtime.current_chunks, b'', 0, chunks)\n"
     }
     | space string:x -> {
-        "append_data(runtime.current_chunk_buffer, b" x ", 0)\n"
+        "append_data(runtime.current_chunks, b" x ", 0)\n"
     }
     | space '#' name:x '(' wvar:y ' ' actionPrimitiveExpression:z ')' -> {
-        >namedBuffers {
-            "W_" y " = None\n"
-        }
         "runtime.W_" y " = " x "(runtime.W_" y " or 0, " z ")\n"
     }
     | space '>' actionexpr*:xs space '<' -> {
-        "append_data(runtime.current_chunk_buffer, b'', 1)\n"
+        "append_data(runtime.current_chunks, b'', 1)\n"
         xs
-        "append_data(runtime.current_chunk_buffer, b'', -1)\n"
+        "append_data(runtime.current_chunks, b'', -1)\n"
     }
     ;
 
+chunkName = name:x -> {
+    >namedChunks {
+        unseen(x) -> {
+            "named_chunks_" x " = None\n"
+        }
+    }
+    x
+};
+
 actionPrimitiveExpression =
     | dotname:x -> { x }
     | digit
@@ -430,7 +432,7 @@ digit =
 
 placeholder
     = '{' space string:x '*' expr:y space '}' -> {
-        "append_data(runtime.current_chunk_buffer, b" x "*" y ", 0)\n"
+        "append_data(runtime.current_chunks, b" x "*" y ", 0)\n"
     }
     ;
 
@@ -451,7 +453,14 @@ dotname = name:x nextname*:xs -> {
 
 nextname = '.' name;
 
-wvar = 'W[' .:x ']' -> { x };
+wvar = 'W[' .:x ']' -> {
+    >namedWs {
+        unseen(x) -> {
+            "W_" x " = None\n"
+        }
+    }
+    x
+};
 
 stringinner = !stringend .;
 

commit daa49b1cbcdac3ca6994c687f7cff67156b38d9e
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Fri Oct 31 07:48:31 2025 +0100

    Make dynamic struct members unique with the help of new primitive unseen

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 2321054..ff464ed 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -12,7 +12,6 @@ class Runtime:
     namedBuffers_chunk_buffer = None
     W_1 = None
     placeholder_chunk_buffer = None
-    namedBuffers_chunk_buffer = None
     placeholders = None
 
 class Action:
@@ -35,6 +34,11 @@ class Variable:
 class ChunkBuffer:
     pre_first = None
     last = None
+    seen = None
+
+class SeenData:
+    next = None
+    data = None
 
 class Chunk:
     next = None
@@ -113,6 +117,18 @@ def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):
     chunk_buffer.last.next = chunk
     chunk_buffer.last = chunk
 
+def seen(chunk_buffer, data):
+    seen_data = chunk_buffer.seen
+    while seen_data:
+        if seen_data.data == data:
+            return True
+        seen_data = seen_data.next
+    seen = SeenData()
+    seen.next = chunk_buffer.seen
+    seen.data = data
+    chunk_buffer.seen = seen
+    return False
+
 def append_named_action(variables, name, action):
     next_variable = Variable()
     next_variable.next = None
@@ -208,6 +224,13 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
     append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"seen = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class SeenData:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"data = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Chunk:\n", 0)
@@ -319,6 +342,24 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def seen(chunk_buffer, data):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"seen_data = chunk_buffer.seen\n", 0)
+    append_data(runtime.current_chunk_buffer, b"while seen_data:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"if seen_data.data == data:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"return True\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"seen_data = seen_data.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"seen = SeenData()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"seen.next = chunk_buffer.seen\n", 0)
+    append_data(runtime.current_chunk_buffer, b"seen.data = data\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer.seen = seen\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return False\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def append_named_action(variables, name, action):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"next_variable = Variable()\n", 0)
@@ -563,6 +604,17 @@ def action_20(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_21(runtime, variables):
+    pass
+    append_data(runtime.current_chunk_buffer, b"action = lookup_action(variables, '", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
+    append_data(runtime.current_chunk_buffer, b"')\n", 0)
+    append_data(runtime.current_chunk_buffer, b"if not seen(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end]):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"pass\n", 0)
+    run_action(lookup_action(variables, 'ys'), runtime)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+
+def action_22(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = runtime.", 0)
@@ -574,11 +626,14 @@ def action_21(runtime, variables):
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.namedBuffers_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"_chunk_buffer = None\n", 0)
+    action = lookup_action(variables, 'x')
+    if not seen(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end]):
+        pass
+        run_action(lookup_action(variables, 'x'), runtime)
+        append_data(runtime.current_chunk_buffer, b"_chunk_buffer = None\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
 
-def action_22(runtime, variables):
+def action_23(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.", 0)
@@ -586,19 +641,19 @@ def action_22(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"_chunk_buffer = chunk_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
-def action_23(runtime, variables):
+def action_24(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, str(", 0)
     run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b").encode('ascii'), 0)\n", 0)
 
-def action_24(runtime, variables):
+def action_25(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"run_action(lookup_action(variables, '", 0)
     run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"'), runtime)\n", 0)
 
-def action_25(runtime, variables):
+def action_26(runtime, variables):
     pass
     runtime.W_1 = inc(runtime.W_1 or 0, 1)
     last_chunk_buffer = runtime.current_chunk_buffer
@@ -619,13 +674,13 @@ def action_25(runtime, variables):
     append_data(runtime.current_chunk_buffer, b", variables, '', 0, 0))\n", 0)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
-def action_26(runtime, variables):
+def action_27(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
     run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
 
-def action_27(runtime, variables):
+def action_28(runtime, variables):
     pass
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.namedBuffers_chunk_buffer
@@ -644,17 +699,17 @@ def action_27(runtime, variables):
     run_action(lookup_action(variables, 'z'), runtime)
     append_data(runtime.current_chunk_buffer, b")\n", 0)
 
-def action_28(runtime, variables):
+def action_29(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 1)\n", 0)
     run_action(lookup_action(variables, 'xs'), runtime)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', -1)\n", 0)
 
-def action_29(runtime, variables):
+def action_30(runtime, variables):
     pass
     run_action(lookup_action(variables, 'x'), runtime)
 
-def action_30(runtime, variables):
+def action_31(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
     run_action(lookup_action(variables, 'x'), runtime)
@@ -662,13 +717,13 @@ def action_30(runtime, variables):
     run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
 
-def action_31(runtime, variables):
+def action_32(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"(runtime.W_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b" or 0)", 0)
 
-def action_32(runtime, variables):
+def action_33(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"((runtime.W_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
@@ -676,18 +731,18 @@ def action_32(runtime, variables):
     run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b")", 0)
 
-def action_33(runtime, variables):
+def action_34(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"lookup_action(variables, '", 0)
     run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"')", 0)
     run_action(lookup_action(variables, 'xs'), runtime)
 
-def action_34(runtime, variables):
+def action_35(runtime, variables):
     pass
     run_action(lookup_action(variables, 'x'), runtime)
 
-def action_35(runtime, variables):
+def action_36(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"'", 0)
 
@@ -1036,6 +1091,50 @@ def rule_actionexpr(parse_state):
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_space(parse_state)
+    if _ != ERROR:
+        data = b'unseen('
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        else:
+            _ = ERROR
+        if _ != ERROR:
+            _ = rule_name(parse_state)
+            append_named_action(variables, 'x', _)
+            if _ != ERROR:
+                data = b') -> {'
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                else:
+                    _ = ERROR
+                if _ != ERROR:
+                    star_variables = create_variables()
+                    star_start_pos = parse_state.pos
+                    while True:
+                        star_pos = parse_state.pos
+                        _ = rule_actionexpr(parse_state)
+                        if _ == ERROR:
+                            parse_state.pos = star_pos
+                            break
+                        append_named_action(star_variables, None, _)
+                    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                    append_named_action(variables, 'ys', _)
+                    if _ != ERROR:
+                        _ = rule_space(parse_state)
+                        if _ != ERROR:
+                            data = b'}'
+                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                parse_state.pos += len(data)
+                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                            else:
+                                _ = ERROR
+                            if _ != ERROR:
+                                return create_action(action_21, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
+    variables = create_variables()
+    _ = rule_space(parse_state)
     if _ != ERROR:
         data = b'>'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1077,7 +1176,7 @@ def rule_actionexpr(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return create_action(action_21, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return create_action(action_22, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1093,7 +1192,7 @@ def rule_actionexpr(parse_state):
             _ = rule_name(parse_state)
             append_named_action(variables, 'x', _)
             if _ != ERROR:
-                return create_action(action_22, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1102,7 +1201,7 @@ def rule_actionexpr(parse_state):
         _ = rule_expr(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return create_action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_24, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1111,7 +1210,7 @@ def rule_actionexpr(parse_state):
         _ = rule_name(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return create_action(action_24, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_25, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1120,7 +1219,7 @@ def rule_actionexpr(parse_state):
         _ = rule_placeholder(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return create_action(action_25, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_26, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1129,7 +1228,7 @@ def rule_actionexpr(parse_state):
         _ = rule_string(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return create_action(action_26, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_27, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1172,7 +1271,7 @@ def rule_actionexpr(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return create_action(action_27, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return create_action(action_28, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1206,7 +1305,7 @@ def rule_actionexpr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return create_action(action_28, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return create_action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionPrimitiveExpression(parse_state):
@@ -1217,7 +1316,7 @@ def rule_actionPrimitiveExpression(parse_state):
     _ = rule_dotname(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return create_action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1376,7 +1475,7 @@ def rule_placeholder(parse_state):
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return create_action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return create_action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_expr(parse_state):
@@ -1387,7 +1486,7 @@ def rule_expr(parse_state):
     _ = rule_wvar(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return create_action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1418,7 +1517,7 @@ def rule_expr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return create_action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return create_action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_string(parse_state):
@@ -1474,7 +1573,7 @@ def rule_dotname(parse_state):
         _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         append_named_action(variables, 'xs', _)
         if _ != ERROR:
-            return create_action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_nextname(parse_state):
@@ -1520,7 +1619,7 @@ def rule_wvar(parse_state):
             else:
                 _ = ERROR
             if _ != ERROR:
-                return create_action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringinner(parse_state):
@@ -1610,7 +1709,7 @@ def rule_innercharstring(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        return create_action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_36, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 6ae0880..6089d00 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -38,6 +38,12 @@ file = rule*:xs space !. -> {
     "class ChunkBuffer:\n" >
         "pre_first = None\n"
         "last = None\n"
+        "seen = None\n"
+    <
+    "\n"
+    "class SeenData:\n" >
+        "next = None\n"
+        "data = None\n"
     <
     "\n"
     "class Chunk:\n" >
@@ -133,6 +139,21 @@ file = rule*:xs space !. -> {
         "chunk_buffer.last = chunk\n"
     <
     "\n"
+    "def seen(chunk_buffer, data):\n" >
+        "seen_data = chunk_buffer.seen\n"
+        "while seen_data:\n" >
+            "if seen_data.data == data:\n" >
+                "return True\n"
+            <
+            "seen_data = seen_data.next\n"
+        <
+        "seen = SeenData()\n"
+        "seen.next = chunk_buffer.seen\n"
+        "seen.data = data\n"
+        "chunk_buffer.seen = seen\n"
+        "return False\n"
+    <
+    "\n"
     "def append_named_action(variables, name, action):\n" >
         "next_variable = Variable()\n"
         "next_variable.next = None\n"
@@ -330,6 +351,13 @@ action =
     ;
 
 actionexpr =
+    | space 'unseen(' name:x ') -> {' actionexpr*:ys space '}' -> {
+        "action = lookup_action(variables, '" x "')\n"
+        "if not seen(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end]):\n" >
+            "pass\n"
+            ys
+        <
+    }
     | space '>' name:x space '{' actionexpr*:ys space '}' -> {
         "last_chunk_buffer = runtime.current_chunk_buffer\n"
         "chunk_buffer = runtime." x "_chunk_buffer\n"
@@ -337,7 +365,9 @@ actionexpr =
         ys
         "runtime.current_chunk_buffer = last_chunk_buffer\n"
         >namedBuffers {
-            x "_chunk_buffer = None\n"
+            unseen(x) -> {
+                x "_chunk_buffer = None\n"
+            }
         }
     }
     | space '<' name:x -> {

2025-10-30 23:01 Rickard pushed to rlmeta2

commit e60f7dd5b6152638d092ef16e4dbfb51369a49ce
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 21:31:59 2025 +0100

    Convert placeholders list to linked list structures

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 26d2067..2321054 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -42,6 +42,15 @@ class Chunk:
     chunk_buffer = None
     indentation_delta = None
 
+class Placeholders:
+    pre_first = None
+    last = None
+
+class Placeholder:
+    next = None
+    chunk_buffer = None
+    action = None
+
 def create_parse_state_from_stdin():
     parse_state = ParseState()
     parse_state.input_buffer = sys.stdin.buffer.read()
@@ -52,7 +61,7 @@ def create_runtime():
     runtime = Runtime()
     runtime.output_chunk_buffer = create_chunk_buffer()
     runtime.current_chunk_buffer = runtime.output_chunk_buffer
-    runtime.placeholders = []
+    runtime.placeholders = create_placeholders()
     return runtime
 
 def create_action(function, variables, input_buffer, start, end):
@@ -77,6 +86,12 @@ def create_chunk_buffer():
     chunk_buffer.last = chunk_buffer.pre_first
     return chunk_buffer
 
+def create_placeholders():
+    placeholders = Placeholder()
+    placeholders.pre_first = Placeholder()
+    placeholders.last = placeholders.pre_first
+    return placeholders
+
 def run_action(action, runtime):
     if action.function is None:
         if action.variables is None:
@@ -115,6 +130,14 @@ def lookup_action(variables, name_to_look_for):
             variable = variable.next
     raise ValueError(f'variable {name_to_look_for} not found')
 
+def append_placeholder(placeholders, chunk_buffer, action):
+    next_variable = Placeholder()
+    next_variable.next = None
+    next_variable.chunk_buffer = chunk_buffer
+    next_variable.action = action
+    placeholders.last.next = next_variable
+    placeholders.last = next_variable
+
 def inc(value, amount):
     return value + amount
 
@@ -195,6 +218,19 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"indentation_delta = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Placeholders:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Placeholder:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def create_parse_state_from_stdin():\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state = ParseState()\n", 0)
@@ -208,7 +244,7 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"runtime = Runtime()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.output_chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = runtime.output_chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.placeholders = []\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.placeholders = create_placeholders()\n", 0)
     append_data(runtime.current_chunk_buffer, b"return runtime\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
@@ -240,6 +276,14 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"return chunk_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_placeholders():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"placeholders = Placeholder()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"placeholders.pre_first = Placeholder()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"placeholders.last = placeholders.pre_first\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return placeholders\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def run_action(action, runtime):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"if action.function is None:\n", 0)
@@ -302,6 +346,16 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def append_placeholder(placeholders, chunk_buffer, action):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"next_variable = Placeholder()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.chunk_buffer = chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.action = action\n", 0)
+    append_data(runtime.current_chunk_buffer, b"placeholders.last.next = next_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"placeholders.last = next_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def inc(value, amount):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"return value + amount\n", 0)
@@ -350,10 +404,12 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"sys.exit('Parse error')\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"run_action(action, runtime)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"for chunk_buffer, action in runtime.placeholders:\n", 0)
+    append_data(runtime.current_chunk_buffer, b"placeholder = runtime.placeholders.pre_first.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b"while placeholder:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"run_action(action, runtime)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = placeholder.chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"run_action(placeholder.action, runtime)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"placeholder = placeholder.next\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
@@ -558,9 +614,9 @@ def action_25(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((chunk_buffer, create_action(placeholder_", 0)
+    append_data(runtime.current_chunk_buffer, b"append_placeholder(runtime.placeholders, chunk_buffer, create_action(placeholder_", 0)
     append_data(runtime.current_chunk_buffer, str((runtime.W_1 or 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b", variables, '', 0, 0)))\n", 0)
+    append_data(runtime.current_chunk_buffer, b", variables, '', 0, 0))\n", 0)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
 def action_26(runtime, variables):
@@ -2224,7 +2280,9 @@ if __name__ == '__main__':
     if action == ERROR:
         sys.exit('Parse error')
     run_action(action, runtime)
-    for chunk_buffer, action in runtime.placeholders:
-        runtime.current_chunk_buffer = chunk_buffer
-        run_action(action, runtime)
+    placeholder = runtime.placeholders.pre_first.next
+    while placeholder:
+        runtime.current_chunk_buffer = placeholder.chunk_buffer
+        run_action(placeholder.action, runtime)
+        placeholder = placeholder.next
     render_chunk_buffer(runtime.output_chunk_buffer)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 204dbf3..6ae0880 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -47,6 +47,17 @@ file = rule*:xs space !. -> {
         "indentation_delta = None\n"
     <
     "\n"
+    "class Placeholders:\n" >
+        "pre_first = None\n"
+        "last = None\n"
+    <
+    "\n"
+    "class Placeholder:\n" >
+        "next = None\n"
+        "chunk_buffer = None\n"
+        "action = None\n"
+    <
+    "\n"
     "def create_parse_state_from_stdin():\n" >
         "parse_state = ParseState()\n"
         "parse_state.input_buffer = sys.stdin.buffer.read()\n"
@@ -58,7 +69,7 @@ file = rule*:xs space !. -> {
         "runtime = Runtime()\n"
         "runtime.output_chunk_buffer = create_chunk_buffer()\n"
         "runtime.current_chunk_buffer = runtime.output_chunk_buffer\n"
-        "runtime.placeholders = []\n"
+        "runtime.placeholders = create_placeholders()\n"
         "return runtime\n"
     <
     "\n"
@@ -87,6 +98,13 @@ file = rule*:xs space !. -> {
         "return chunk_buffer\n"
     <
     "\n"
+    "def create_placeholders():\n" >
+        "placeholders = Placeholder()\n"
+        "placeholders.pre_first = Placeholder()\n"
+        "placeholders.last = placeholders.pre_first\n"
+        "return placeholders\n"
+    <
+    "\n"
     "def run_action(action, runtime):\n" >
         "if action.function is None:\n" >
             "if action.variables is None:\n" >
@@ -137,6 +155,15 @@ file = rule*:xs space !. -> {
         "raise ValueError(f'variable {name_to_look_for} not found')\n"
     <
     "\n"
+    "def append_placeholder(placeholders, chunk_buffer, action):\n" >
+        "next_variable = Placeholder()\n"
+        "next_variable.next = None\n"
+        "next_variable.chunk_buffer = chunk_buffer\n"
+        "next_variable.action = action\n"
+        "placeholders.last.next = next_variable\n"
+        "placeholders.last = next_variable\n"
+    <
+    "\n"
     "def inc(value, amount):\n" >
         "return value + amount\n"
     <
@@ -173,9 +200,11 @@ file = rule*:xs space !. -> {
             "sys.exit('Parse error')\n"
         <
         "run_action(action, runtime)\n"
-        "for chunk_buffer, action in runtime.placeholders:\n" >
-            "runtime.current_chunk_buffer = chunk_buffer\n"
-            "run_action(action, runtime)\n"
+        "placeholder = runtime.placeholders.pre_first.next\n"
+        "while placeholder:\n" >
+            "runtime.current_chunk_buffer = placeholder.chunk_buffer\n"
+            "run_action(placeholder.action, runtime)\n"
+            "placeholder = placeholder.next\n"
         <
         "render_chunk_buffer(runtime.output_chunk_buffer)\n"
     <
@@ -332,7 +361,7 @@ actionexpr =
             "\n"
         }
         "chunk_buffer = create_chunk_buffer()\n"
-        "runtime.placeholders.append((chunk_buffer, create_action(placeholder_" W[1] ", variables, '', 0, 0)))\n"
+        "append_placeholder(runtime.placeholders, chunk_buffer, create_action(placeholder_" W[1] ", variables, '', 0, 0))\n"
         "append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n"
     }
     | space string:x -> {

commit 465f136551416b93f93a3ae92b4c9ccbc841c07d
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 21:29:21 2025 +0100

    Exit on parse error

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 51141da..26d2067 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -344,7 +344,12 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state = create_parse_state_from_stdin()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime = create_runtime()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"run_action(rule_main(parse_state), runtime)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action = rule_main(parse_state)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"if action == ERROR:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"sys.exit('Parse error')\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"run_action(action, runtime)\n", 0)
     append_data(runtime.current_chunk_buffer, b"for chunk_buffer, action in runtime.placeholders:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
@@ -2215,7 +2220,10 @@ def rule_spacechar(parse_state):
 if __name__ == '__main__':
     parse_state = create_parse_state_from_stdin()
     runtime = create_runtime()
-    run_action(rule_main(parse_state), runtime)
+    action = rule_main(parse_state)
+    if action == ERROR:
+        sys.exit('Parse error')
+    run_action(action, runtime)
     for chunk_buffer, action in runtime.placeholders:
         runtime.current_chunk_buffer = chunk_buffer
         run_action(action, runtime)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 5b0d433..204dbf3 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -168,7 +168,11 @@ file = rule*:xs space !. -> {
     "if __name__ == '__main__':\n" >
         "parse_state = create_parse_state_from_stdin()\n"
         "runtime = create_runtime()\n"
-        "run_action(rule_main(parse_state), runtime)\n"
+        "action = rule_main(parse_state)\n"
+        "if action == ERROR:\n" >
+            "sys.exit('Parse error')\n"
+        <
+        "run_action(action, runtime)\n"
         "for chunk_buffer, action in runtime.placeholders:\n" >
             "runtime.current_chunk_buffer = chunk_buffer\n"
             "run_action(action, runtime)\n"

commit b223d4259b329e4ff85f5c8963039e2a59c68aa6
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 21:20:24 2025 +0100

    Get rid of W map {}

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index d34dfcb..51141da 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -7,11 +7,13 @@ class ParseState:
 class Runtime:
     output_chunk_buffer = None
     current_chunk_buffer = None
+    W_0 = None
     action_chunk_buffer = None
     namedBuffers_chunk_buffer = None
+    W_1 = None
     placeholder_chunk_buffer = None
+    namedBuffers_chunk_buffer = None
     placeholders = None
-    W = None
 
 class Action:
     function = None
@@ -51,7 +53,6 @@ def create_runtime():
     runtime.output_chunk_buffer = create_chunk_buffer()
     runtime.current_chunk_buffer = runtime.output_chunk_buffer
     runtime.placeholders = []
-    runtime.W = {}
     return runtime
 
 def create_action(function, variables, input_buffer, start, end):
@@ -155,7 +156,6 @@ def action_2(runtime, variables):
     runtime.namedBuffers_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
     append_data(runtime.current_chunk_buffer, b"placeholders = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"W = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Action:\n", 0)
@@ -209,7 +209,6 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"runtime.output_chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = runtime.output_chunk_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.placeholders = []\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.W = {}\n", 0)
     append_data(runtime.current_chunk_buffer, b"return runtime\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
@@ -481,12 +480,12 @@ def action_18(runtime, variables):
 
 def action_19(runtime, variables):
     pass
-    runtime.W[0] = inc(runtime.W.get(0, 0), 1)
+    runtime.W_0 = inc(runtime.W_0 or 0, 1)
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.action_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b"def action_", 0)
-    append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, str((runtime.W_0 or 0)).encode('ascii'), 0)
     append_data(runtime.current_chunk_buffer, b"(runtime, variables):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"pass\n", 0)
@@ -495,7 +494,7 @@ def action_19(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
     append_data(runtime.current_chunk_buffer, b"return create_action(action_", 0)
-    append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, str((runtime.W_0 or 0)).encode('ascii'), 0)
     append_data(runtime.current_chunk_buffer, b", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variables):
@@ -540,12 +539,12 @@ def action_24(runtime, variables):
 
 def action_25(runtime, variables):
     pass
-    runtime.W[1] = inc(runtime.W.get(1, 0), 1)
+    runtime.W_1 = inc(runtime.W_1 or 0, 1)
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.placeholder_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b"def placeholder_", 0)
-    append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, str((runtime.W_1 or 0)).encode('ascii'), 0)
     append_data(runtime.current_chunk_buffer, b"(runtime, variables):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"pass\n", 0)
@@ -555,7 +554,7 @@ def action_25(runtime, variables):
     runtime.current_chunk_buffer = last_chunk_buffer
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((chunk_buffer, create_action(placeholder_", 0)
-    append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, str((runtime.W_1 or 0)).encode('ascii'), 0)
     append_data(runtime.current_chunk_buffer, b", variables, '', 0, 0)))\n", 0)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
@@ -567,13 +566,20 @@ def action_26(runtime, variables):
 
 def action_27(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"runtime.W[", 0)
+    last_chunk_buffer = runtime.current_chunk_buffer
+    chunk_buffer = runtime.namedBuffers_chunk_buffer
+    runtime.current_chunk_buffer = chunk_buffer
+    append_data(runtime.current_chunk_buffer, b"W_", 0)
+    run_action(lookup_action(variables, 'y'), runtime)
+    append_data(runtime.current_chunk_buffer, b" = None\n", 0)
+    runtime.current_chunk_buffer = last_chunk_buffer
+    append_data(runtime.current_chunk_buffer, b"runtime.W_", 0)
     run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b"] = ", 0)
+    append_data(runtime.current_chunk_buffer, b" = ", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"(runtime.W.get(", 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime.W_", 0)
     run_action(lookup_action(variables, 'y'), runtime)
-    append_data(runtime.current_chunk_buffer, b", 0), ", 0)
+    append_data(runtime.current_chunk_buffer, b" or 0, ", 0)
     run_action(lookup_action(variables, 'z'), runtime)
     append_data(runtime.current_chunk_buffer, b")\n", 0)
 
@@ -597,15 +603,15 @@ def action_30(runtime, variables):
 
 def action_31(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"runtime.W.get(", 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime.W_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b", 0)", 0)
+    append_data(runtime.current_chunk_buffer, b" or 0)", 0)
 
 def action_32(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"(runtime.W.get(", 0)
+    append_data(runtime.current_chunk_buffer, b"((runtime.W_", 0)
     run_action(lookup_action(variables, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b", 0)-", 0)
+    append_data(runtime.current_chunk_buffer, b" or 0)-", 0)
     run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b")", 0)
 
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 11ce175..5b0d433 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -13,7 +13,6 @@ file = rule*:xs space !. -> {
         "current_chunk_buffer = None\n"
         <namedBuffers
         "placeholders = None\n"
-        "W = None\n"
     <
     "\n"
     "class Action:\n" >
@@ -60,7 +59,6 @@ file = rule*:xs space !. -> {
         "runtime.output_chunk_buffer = create_chunk_buffer()\n"
         "runtime.current_chunk_buffer = runtime.output_chunk_buffer\n"
         "runtime.placeholders = []\n"
-        "runtime.W = {}\n"
         "return runtime\n"
     <
     "\n"
@@ -337,7 +335,10 @@ actionexpr =
         "append_data(runtime.current_chunk_buffer, b" x ", 0)\n"
     }
     | space '#' name:x '(' wvar:y ' ' actionPrimitiveExpression:z ')' -> {
-        "runtime.W[" y "] = " x "(runtime.W.get(" y ", 0), " z ")\n"
+        >namedBuffers {
+            "W_" y " = None\n"
+        }
+        "runtime.W_" y " = " x "(runtime.W_" y " or 0, " z ")\n"
     }
     | space '>' actionexpr*:xs space '<' -> {
         "append_data(runtime.current_chunk_buffer, b'', 1)\n"
@@ -372,10 +373,10 @@ placeholder
 
 expr =
     | wvar:x -> {
-        "runtime.W.get(" x ", 0)"
+        "(runtime.W_" x " or 0)"
     }
     | '(' wvar:x '-' dotname:y ')' -> {
-        "(runtime.W.get(" x ", 0)-"  y ")"
+        "((runtime.W_" x " or 0)-"  y ")"
     }
     ;
 

commit a0117b0e7051a01c928b55b93f4ca98823b62a04
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 21:11:00 2025 +0100

    Perhaps cleaner order

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index cd93659..d34dfcb 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -21,6 +21,15 @@ class Action:
     end = None
     len = None
 
+class Variables:
+    pre_first = None
+    last = None
+
+class Variable:
+    next = None
+    name = None
+    action = None
+
 class ChunkBuffer:
     pre_first = None
     last = None
@@ -31,14 +40,11 @@ class Chunk:
     chunk_buffer = None
     indentation_delta = None
 
-class Variables:
-    pre_first = None
-    last = None
-
-class Variable:
-    next = None
-    name = None
-    action = None
+def create_parse_state_from_stdin():
+    parse_state = ParseState()
+    parse_state.input_buffer = sys.stdin.buffer.read()
+    parse_state.pos = 0
+    return parse_state
 
 def create_runtime():
     runtime = Runtime()
@@ -48,12 +54,6 @@ def create_runtime():
     runtime.W = {}
     return runtime
 
-def create_parse_state_from_stdin():
-    parse_state = ParseState()
-    parse_state.input_buffer = sys.stdin.buffer.read()
-    parse_state.pos = 0
-    return parse_state
-
 def create_action(function, variables, input_buffer, start, end):
     action = Action()
     action.function = function
@@ -64,18 +64,6 @@ def create_action(function, variables, input_buffer, start, end):
     action.len = end-start
     return action
 
-def run_action(action, runtime):
-    if action.function is None:
-        if action.variables is None:
-            append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)
-        else:
-            variable = action.variables.pre_first.next
-            while variable:
-                run_action(variable.action, runtime)
-                variable = variable.next
-    else:
-        action.function(runtime, action.variables)
-
 def create_variables():
     variables = Variables()
     variables.pre_first = Variable()
@@ -88,6 +76,18 @@ def create_chunk_buffer():
     chunk_buffer.last = chunk_buffer.pre_first
     return chunk_buffer
 
+def run_action(action, runtime):
+    if action.function is None:
+        if action.variables is None:
+            append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)
+        else:
+            variable = action.variables.pre_first.next
+            while variable:
+                run_action(variable.action, runtime)
+                variable = variable.next
+    else:
+        action.function(runtime, action.variables)
+
 def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):
     chunk = Chunk()
     chunk.next = None
@@ -168,31 +168,39 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"len = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class ChunkBuffer:\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Variables:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
     append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Chunk:\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Variable:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"data = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"indentation_delta = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"name = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Variables:\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class ChunkBuffer:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
     append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Variable:\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Chunk:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"name = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"data = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"indentation_delta = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_parse_state_from_stdin():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"parse_state = ParseState()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"parse_state.input_buffer = sys.stdin.buffer.read()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"parse_state.pos = 0\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return parse_state\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def create_runtime():\n", 0)
@@ -205,14 +213,6 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"return runtime\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_parse_state_from_stdin():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"parse_state = ParseState()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"parse_state.input_buffer = sys.stdin.buffer.read()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"parse_state.pos = 0\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return parse_state\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def create_action(function, variables, input_buffer, start, end):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"action = Action()\n", 0)
@@ -225,6 +225,22 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"return action\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_variables():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"variables = Variables()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables.pre_first = Variable()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables.last = variables.pre_first\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return variables\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_chunk_buffer():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = ChunkBuffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer.pre_first = Chunk()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk_buffer.pre_first\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def run_action(action, runtime):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"if action.function is None:\n", 0)
@@ -249,22 +265,6 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_variables():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"variables = Variables()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables.pre_first = Variable()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variables.last = variables.pre_first\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return variables\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def create_chunk_buffer():\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer = ChunkBuffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer.pre_first = Chunk()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk_buffer.pre_first\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"chunk = Chunk()\n", 0)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 2de223a..11ce175 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -25,27 +25,34 @@ file = rule*:xs space !. -> {
         "len = None\n"
     <
     "\n"
-    "class ChunkBuffer:\n" >
+    "class Variables:\n" >
         "pre_first = None\n"
         "last = None\n"
     <
     "\n"
-    "class Chunk:\n" >
+    "class Variable:\n" >
         "next = None\n"
-        "data = None\n"
-        "chunk_buffer = None\n"
-        "indentation_delta = None\n"
+        "name = None\n"
+        "action = None\n"
     <
     "\n"
-    "class Variables:\n" >
+    "class ChunkBuffer:\n" >
         "pre_first = None\n"
         "last = None\n"
     <
     "\n"
-    "class Variable:\n" >
+    "class Chunk:\n" >
         "next = None\n"
-        "name = None\n"
-        "action = None\n"
+        "data = None\n"
+        "chunk_buffer = None\n"
+        "indentation_delta = None\n"
+    <
+    "\n"
+    "def create_parse_state_from_stdin():\n" >
+        "parse_state = ParseState()\n"
+        "parse_state.input_buffer = sys.stdin.buffer.read()\n"
+        "parse_state.pos = 0\n"
+        "return parse_state\n"
     <
     "\n"
     "def create_runtime():\n" >
@@ -57,13 +64,6 @@ file = rule*:xs space !. -> {
         "return runtime\n"
     <
     "\n"
-    "def create_parse_state_from_stdin():\n" >
-        "parse_state = ParseState()\n"
-        "parse_state.input_buffer = sys.stdin.buffer.read()\n"
-        "parse_state.pos = 0\n"
-        "return parse_state\n"
-    <
-    "\n"
     "def create_action(function, variables, input_buffer, start, end):\n" >
         "action = Action()\n"
         "action.function = function\n"
@@ -75,6 +75,20 @@ file = rule*:xs space !. -> {
         "return action\n"
     <
     "\n"
+    "def create_variables():\n" >
+        "variables = Variables()\n"
+        "variables.pre_first = Variable()\n"
+        "variables.last = variables.pre_first\n"
+        "return variables\n"
+    <
+    "\n"
+    "def create_chunk_buffer():\n" >
+        "chunk_buffer = ChunkBuffer()\n"
+        "chunk_buffer.pre_first = Chunk()\n"
+        "chunk_buffer.last = chunk_buffer.pre_first\n"
+        "return chunk_buffer\n"
+    <
+    "\n"
     "def run_action(action, runtime):\n" >
         "if action.function is None:\n" >
             "if action.variables is None:\n" >
@@ -93,20 +107,6 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
-    "def create_variables():\n" >
-        "variables = Variables()\n"
-        "variables.pre_first = Variable()\n"
-        "variables.last = variables.pre_first\n"
-        "return variables\n"
-    <
-    "\n"
-    "def create_chunk_buffer():\n" >
-        "chunk_buffer = ChunkBuffer()\n"
-        "chunk_buffer.pre_first = Chunk()\n"
-        "chunk_buffer.last = chunk_buffer.pre_first\n"
-        "return chunk_buffer\n"
-    <
-    "\n"
     "def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n" >
         "chunk = Chunk()\n"
         "chunk.next = None\n"

commit 49659f4317e8f439d7213077761165fee103529d
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 21:04:54 2025 +0100

    C-like struct for Runtime

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 65a0ccc..cd93659 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -5,14 +5,13 @@ class ParseState:
     pos = None
 
 class Runtime:
-    def __init__(self):
-        self.output_chunk_buffer = create_chunk_buffer()
-        self.current_chunk_buffer = self.output_chunk_buffer
-        self.action_chunk_buffer = None
-        self.namedBuffers_chunk_buffer = None
-        self.placeholder_chunk_buffer = None
-        self.placeholders = []
-        self.W = {}
+    output_chunk_buffer = None
+    current_chunk_buffer = None
+    action_chunk_buffer = None
+    namedBuffers_chunk_buffer = None
+    placeholder_chunk_buffer = None
+    placeholders = None
+    W = None
 
 class Action:
     function = None
@@ -41,6 +40,14 @@ class Variable:
     name = None
     action = None
 
+def create_runtime():
+    runtime = Runtime()
+    runtime.output_chunk_buffer = create_chunk_buffer()
+    runtime.current_chunk_buffer = runtime.output_chunk_buffer
+    runtime.placeholders = []
+    runtime.W = {}
+    return runtime
+
 def create_parse_state_from_stdin():
     parse_state = ParseState()
     parse_state.input_buffer = sys.stdin.buffer.read()
@@ -142,16 +149,13 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Runtime:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"self.output_chunk_buffer = create_chunk_buffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"output_chunk_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"current_chunk_buffer = None\n", 0)
     chunk_buffer = create_chunk_buffer()
     runtime.namedBuffers_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
-    append_data(runtime.current_chunk_buffer, b"self.placeholders = []\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.W = {}\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"placeholders = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"W = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Action:\n", 0)
@@ -191,6 +195,16 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_runtime():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"runtime = Runtime()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.output_chunk_buffer = create_chunk_buffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = runtime.output_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.placeholders = []\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.W = {}\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return runtime\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def create_parse_state_from_stdin():\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state = ParseState()\n", 0)
@@ -330,7 +344,7 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"if __name__ == '__main__':\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state = create_parse_state_from_stdin()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime = Runtime()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime = create_runtime()\n", 0)
     append_data(runtime.current_chunk_buffer, b"run_action(rule_main(parse_state), runtime)\n", 0)
     append_data(runtime.current_chunk_buffer, b"for chunk_buffer, action in runtime.placeholders:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -500,7 +514,6 @@ def action_21(runtime, variables):
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.namedBuffers_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"self.", 0)
     run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"_chunk_buffer = None\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
@@ -2195,7 +2208,7 @@ def rule_spacechar(parse_state):
 
 if __name__ == '__main__':
     parse_state = create_parse_state_from_stdin()
-    runtime = Runtime()
+    runtime = create_runtime()
     run_action(rule_main(parse_state), runtime)
     for chunk_buffer, action in runtime.placeholders:
         runtime.current_chunk_buffer = chunk_buffer
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 81d5773..2de223a 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -9,13 +9,11 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "class Runtime:\n" >
-        "def __init__(self):\n" >
-            "self.output_chunk_buffer = create_chunk_buffer()\n"
-            "self.current_chunk_buffer = self.output_chunk_buffer\n"
-            <namedBuffers
-            "self.placeholders = []\n"
-            "self.W = {}\n"
-        <
+        "output_chunk_buffer = None\n"
+        "current_chunk_buffer = None\n"
+        <namedBuffers
+        "placeholders = None\n"
+        "W = None\n"
     <
     "\n"
     "class Action:\n" >
@@ -50,6 +48,15 @@ file = rule*:xs space !. -> {
         "action = None\n"
     <
     "\n"
+    "def create_runtime():\n" >
+        "runtime = Runtime()\n"
+        "runtime.output_chunk_buffer = create_chunk_buffer()\n"
+        "runtime.current_chunk_buffer = runtime.output_chunk_buffer\n"
+        "runtime.placeholders = []\n"
+        "runtime.W = {}\n"
+        "return runtime\n"
+    <
+    "\n"
     "def create_parse_state_from_stdin():\n" >
         "parse_state = ParseState()\n"
         "parse_state.input_buffer = sys.stdin.buffer.read()\n"
@@ -162,7 +169,7 @@ file = rule*:xs space !. -> {
     xs
     "if __name__ == '__main__':\n" >
         "parse_state = create_parse_state_from_stdin()\n"
-        "runtime = Runtime()\n"
+        "runtime = create_runtime()\n"
         "run_action(rule_main(parse_state), runtime)\n"
         "for chunk_buffer, action in runtime.placeholders:\n" >
             "runtime.current_chunk_buffer = chunk_buffer\n"
@@ -299,7 +306,7 @@ actionexpr =
         ys
         "runtime.current_chunk_buffer = last_chunk_buffer\n"
         >namedBuffers {
-            "self." x "_chunk_buffer = None\n"
+            x "_chunk_buffer = None\n"
         }
     }
     | space '<' name:x -> {

commit f0d389e7771ec6b4fa40b32208b317a9f896eda4
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 21:01:35 2025 +0100

    Struct like style for ParseState

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index bb19c7d..65a0ccc 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -1,9 +1,8 @@
 import sys
 
 class ParseState:
-    def __init__(self, input_buffer):
-        self.input_buffer = input_buffer
-        self.pos = 0
+    input_buffer = None
+    pos = None
 
 class Runtime:
     def __init__(self):
@@ -42,6 +41,12 @@ class Variable:
     name = None
     action = None
 
+def create_parse_state_from_stdin():
+    parse_state = ParseState()
+    parse_state.input_buffer = sys.stdin.buffer.read()
+    parse_state.pos = 0
+    return parse_state
+
 def create_action(function, variables, input_buffer, start, end):
     action = Action()
     action.function = function
@@ -131,11 +136,8 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class ParseState:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"def __init__(self, input_buffer):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"self.input_buffer = input_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.pos = 0\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"input_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"pos = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Runtime:\n", 0)
@@ -189,6 +191,14 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_parse_state_from_stdin():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"parse_state = ParseState()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"parse_state.input_buffer = sys.stdin.buffer.read()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"parse_state.pos = 0\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return parse_state\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def create_action(function, variables, input_buffer, start, end):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"action = Action()\n", 0)
@@ -319,7 +329,7 @@ def action_2(runtime, variables):
     run_action(lookup_action(variables, 'xs'), runtime)
     append_data(runtime.current_chunk_buffer, b"if __name__ == '__main__':\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"parse_state = ParseState(sys.stdin.buffer.read())\n", 0)
+    append_data(runtime.current_chunk_buffer, b"parse_state = create_parse_state_from_stdin()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime = Runtime()\n", 0)
     append_data(runtime.current_chunk_buffer, b"run_action(rule_main(parse_state), runtime)\n", 0)
     append_data(runtime.current_chunk_buffer, b"for chunk_buffer, action in runtime.placeholders:\n", 0)
@@ -2184,7 +2194,7 @@ def rule_spacechar(parse_state):
     return ERROR
 
 if __name__ == '__main__':
-    parse_state = ParseState(sys.stdin.buffer.read())
+    parse_state = create_parse_state_from_stdin()
     runtime = Runtime()
     run_action(rule_main(parse_state), runtime)
     for chunk_buffer, action in runtime.placeholders:
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index aa6e934..81d5773 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -4,10 +4,8 @@ file = rule*:xs space !. -> {
     "import sys\n"
     "\n"
     "class ParseState:\n" >
-        "def __init__(self, input_buffer):\n" >
-            "self.input_buffer = input_buffer\n"
-            "self.pos = 0\n"
-        <
+        "input_buffer = None\n"
+        "pos = None\n"
     <
     "\n"
     "class Runtime:\n" >
@@ -52,6 +50,13 @@ file = rule*:xs space !. -> {
         "action = None\n"
     <
     "\n"
+    "def create_parse_state_from_stdin():\n" >
+        "parse_state = ParseState()\n"
+        "parse_state.input_buffer = sys.stdin.buffer.read()\n"
+        "parse_state.pos = 0\n"
+        "return parse_state\n"
+    <
+    "\n"
     "def create_action(function, variables, input_buffer, start, end):\n" >
         "action = Action()\n"
         "action.function = function\n"
@@ -156,7 +161,7 @@ file = rule*:xs space !. -> {
     <placeholder
     xs
     "if __name__ == '__main__':\n" >
-        "parse_state = ParseState(sys.stdin.buffer.read())\n"
+        "parse_state = create_parse_state_from_stdin()\n"
         "runtime = Runtime()\n"
         "run_action(rule_main(parse_state), runtime)\n"
         "for chunk_buffer, action in runtime.placeholders:\n" >

commit a2dcba194d2cda366a09813b313df59051964ed5
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 20:59:42 2025 +0100

    More C-like style for action struct

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 1f240c7..bb19c7d 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -16,13 +16,12 @@ class Runtime:
         self.W = {}
 
 class Action:
-    def __init__(self, function, variables, input_buffer, start, end):
-        self.function = function
-        self.variables = variables
-        self.input_buffer = input_buffer
-        self.start = start
-        self.end = end
-        self.len = end-start
+    function = None
+    variables = None
+    input_buffer = None
+    start = None
+    end = None
+    len = None
 
 class ChunkBuffer:
     pre_first = None
@@ -43,6 +42,16 @@ class Variable:
     name = None
     action = None
 
+def create_action(function, variables, input_buffer, start, end):
+    action = Action()
+    action.function = function
+    action.variables = variables
+    action.input_buffer = input_buffer
+    action.start = start
+    action.end = end
+    action.len = end-start
+    return action
+
 def run_action(action, runtime):
     if action.function is None:
         if action.variables is None:
@@ -145,15 +154,12 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Action:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"def __init__(self, function, variables, input_buffer, start, end):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"self.function = function\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.variables = variables\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.input_buffer = input_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.start = start\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.end = end\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.len = end-start\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"function = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"input_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"start = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"end = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"len = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class ChunkBuffer:\n", 0)
@@ -183,6 +189,18 @@ def action_2(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_action(function, variables, input_buffer, start, end):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"action = Action()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action.function = function\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action.variables = variables\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action.input_buffer = input_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action.start = start\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action.end = end\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action.len = end-start\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return action\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def run_action(action, runtime):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"if action.function is None:\n", 0)
@@ -398,7 +416,7 @@ def action_14(runtime, variables):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"append_named_action(star_variables, None, _)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"_ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variables):
     pass
@@ -415,7 +433,7 @@ def action_17(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state.pos += 1\n", 0)
-    append_data(runtime.current_chunk_buffer, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"else:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -430,7 +448,7 @@ def action_18(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state.pos += len(data)\n", 0)
-    append_data(runtime.current_chunk_buffer, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"else:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -452,13 +470,13 @@ def action_19(runtime, variables):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"return Action(action_", 0)
+    append_data(runtime.current_chunk_buffer, b"return create_action(action_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
     append_data(runtime.current_chunk_buffer, b", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_21(runtime, variables):
     pass
@@ -513,7 +531,7 @@ def action_25(runtime, variables):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((chunk_buffer, Action(placeholder_", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((chunk_buffer, create_action(placeholder_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
     append_data(runtime.current_chunk_buffer, b", variables, '', 0, 0)))\n", 0)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
@@ -591,7 +609,7 @@ def rule_main(parse_state):
     _ = rule_file(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_1, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_1, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_file(parse_state):
@@ -608,7 +626,7 @@ def rule_file(parse_state):
             parse_state.pos = star_pos
             break
         append_named_action(star_variables, None, _)
-    _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
     append_named_action(variables, 'xs', _)
     if _ != ERROR:
         _ = rule_space(parse_state)
@@ -616,7 +634,7 @@ def rule_file(parse_state):
             nlookahead_pos = parse_state.pos
             if parse_state.pos != len(parse_state.input_buffer):
                 parse_state.pos += 1
-                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
             else:
                 _ = ERROR
             if _ == ERROR:
@@ -625,7 +643,7 @@ def rule_file(parse_state):
                 _ = ERROR
             parse_state.pos = nlookahead_pos
             if _ != ERROR:
-                return Action(action_2, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_2, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_rule(parse_state):
@@ -643,7 +661,7 @@ def rule_rule(parse_state):
                 data = b'='
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -657,11 +675,11 @@ def rule_rule(parse_state):
                                 data = b';'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
-                                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_3, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return create_action(action_3, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_ors(parse_state):
@@ -683,10 +701,10 @@ def rule_ors(parse_state):
                     parse_state.pos = star_pos
                     break
                 append_named_action(star_variables, None, _)
-            _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
             append_named_action(variables, 'xs', _)
             if _ != ERROR:
-                return Action(action_4, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_4, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_restorcase(parse_state):
@@ -699,7 +717,7 @@ def rule_restorcase(parse_state):
         _ = rule_orcase(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_5, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_5, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_maybeorbar(parse_state):
@@ -709,11 +727,11 @@ def rule_maybeorbar(parse_state):
     variables = create_variables()
     _ = rule_orbar(parse_state)
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
-    return Action(action_6, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return create_action(action_6, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_orbar(parse_state):
@@ -726,11 +744,11 @@ def rule_orbar(parse_state):
         data = b'|'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_orcase(parse_state):
@@ -741,7 +759,7 @@ def rule_orcase(parse_state):
     _ = rule_matchAnd(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_7, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_7, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAnd(parse_state):
@@ -757,14 +775,14 @@ def rule_matchAnd(parse_state):
             _ = rule_matchAnd(parse_state)
             append_named_action(variables, 'y', _)
             if _ != ERROR:
-                return Action(action_8, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_8, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_action(parse_state)
     append_named_action(variables, 'y', _)
     if _ != ERROR:
-        return Action(action_9, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_9, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExpr(parse_state):
@@ -775,14 +793,14 @@ def rule_matchExpr(parse_state):
     data = b'!'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_matchExprPrimitive(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_10, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_10, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -792,7 +810,7 @@ def rule_matchExpr(parse_state):
         _ = rule_matchAssign(parse_state)
         append_named_action(variables, 'y', _)
         if _ != ERROR:
-            return Action(action_11, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_11, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAssign(parse_state):
@@ -803,18 +821,18 @@ def rule_matchAssign(parse_state):
     data = b':'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_name(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_12, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_12, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
-    return Action(action_13, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return create_action(action_13, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprRepeat(parse_state):
@@ -828,18 +846,18 @@ def rule_matchExprRepeat(parse_state):
         data = b'*'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(action_14, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_14, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_matchExprPrimitive(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_15, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_15, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprPrimitive(parse_state):
@@ -850,25 +868,25 @@ def rule_matchExprPrimitive(parse_state):
     _ = rule_name(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_16, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_16, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(action_17, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_17, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_charstring(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_18, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_18, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_action(parse_state):
@@ -881,7 +899,7 @@ def rule_action(parse_state):
         data = b'->'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -890,7 +908,7 @@ def rule_action(parse_state):
                 data = b'{'
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -903,7 +921,7 @@ def rule_action(parse_state):
                             parse_state.pos = star_pos
                             break
                         append_named_action(star_variables, None, _)
-                    _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
                     append_named_action(variables, 'xs', _)
                     if _ != ERROR:
                         _ = rule_space(parse_state)
@@ -911,15 +929,15 @@ def rule_action(parse_state):
                             data = b'}'
                             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                 parse_state.pos += len(data)
-                                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(action_19, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return create_action(action_19, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
-    return Action(action_20, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return create_action(action_20, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionexpr(parse_state):
@@ -932,7 +950,7 @@ def rule_actionexpr(parse_state):
         data = b'>'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -944,7 +962,7 @@ def rule_actionexpr(parse_state):
                     data = b'{'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
-                        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
@@ -957,7 +975,7 @@ def rule_actionexpr(parse_state):
                                 parse_state.pos = star_pos
                                 break
                             append_named_action(star_variables, None, _)
-                        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
                         append_named_action(variables, 'ys', _)
                         if _ != ERROR:
                             _ = rule_space(parse_state)
@@ -965,11 +983,11 @@ def rule_actionexpr(parse_state):
                                 data = b'}'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
-                                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_21, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return create_action(action_21, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -978,14 +996,14 @@ def rule_actionexpr(parse_state):
         data = b'<'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
             _ = rule_name(parse_state)
             append_named_action(variables, 'x', _)
             if _ != ERROR:
-                return Action(action_22, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_22, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -994,7 +1012,7 @@ def rule_actionexpr(parse_state):
         _ = rule_expr(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1003,7 +1021,7 @@ def rule_actionexpr(parse_state):
         _ = rule_name(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_24, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_24, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1012,7 +1030,7 @@ def rule_actionexpr(parse_state):
         _ = rule_placeholder(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_25, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_25, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1021,7 +1039,7 @@ def rule_actionexpr(parse_state):
         _ = rule_string(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_26, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_26, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1030,7 +1048,7 @@ def rule_actionexpr(parse_state):
         data = b'#'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -1040,7 +1058,7 @@ def rule_actionexpr(parse_state):
                 data = b'('
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -1050,7 +1068,7 @@ def rule_actionexpr(parse_state):
                         data = b' '
                         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                             parse_state.pos += len(data)
-                            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                         else:
                             _ = ERROR
                         if _ != ERROR:
@@ -1060,11 +1078,11 @@ def rule_actionexpr(parse_state):
                                 data = b')'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
-                                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_27, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return create_action(action_27, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1073,7 +1091,7 @@ def rule_actionexpr(parse_state):
         data = b'>'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -1086,7 +1104,7 @@ def rule_actionexpr(parse_state):
                     parse_state.pos = star_pos
                     break
                 append_named_action(star_variables, None, _)
-            _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
             append_named_action(variables, 'xs', _)
             if _ != ERROR:
                 _ = rule_space(parse_state)
@@ -1094,11 +1112,11 @@ def rule_actionexpr(parse_state):
                     data = b'<'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
-                        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(action_28, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return create_action(action_28, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionPrimitiveExpression(parse_state):
@@ -1109,13 +1127,13 @@ def rule_actionPrimitiveExpression(parse_state):
     _ = rule_dotname(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_digit(parse_state)
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_digit(parse_state):
@@ -1126,110 +1144,110 @@ def rule_digit(parse_state):
     data = b'0'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'1'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'2'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'3'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'4'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'5'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'6'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'7'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'8'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'9'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_placeholder(parse_state):
@@ -1240,7 +1258,7 @@ def rule_placeholder(parse_state):
     data = b'{'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1252,7 +1270,7 @@ def rule_placeholder(parse_state):
                 data = b'*'
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                    _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -1264,11 +1282,11 @@ def rule_placeholder(parse_state):
                             data = b'}'
                             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                 parse_state.pos += len(data)
-                                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return create_action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_expr(parse_state):
@@ -1279,14 +1297,14 @@ def rule_expr(parse_state):
     _ = rule_wvar(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'('
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1296,7 +1314,7 @@ def rule_expr(parse_state):
             data = b'-'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
-                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
@@ -1306,11 +1324,11 @@ def rule_expr(parse_state):
                     data = b')'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
-                        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return create_action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_string(parse_state):
@@ -1321,7 +1339,7 @@ def rule_string(parse_state):
     data = b'"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1334,16 +1352,16 @@ def rule_string(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             data = b'"'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
-                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_dotname(parse_state):
@@ -1363,10 +1381,10 @@ def rule_dotname(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         append_named_action(variables, 'xs', _)
         if _ != ERROR:
-            return Action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_nextname(parse_state):
@@ -1377,13 +1395,13 @@ def rule_nextname(parse_state):
     data = b'.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_name(parse_state)
         if _ != ERROR:
-            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_wvar(parse_state):
@@ -1394,13 +1412,13 @@ def rule_wvar(parse_state):
     data = b'W['
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         if parse_state.pos != len(parse_state.input_buffer):
             parse_state.pos += 1
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         append_named_action(variables, 'x', _)
@@ -1408,11 +1426,11 @@ def rule_wvar(parse_state):
             data = b']'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
-                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+                _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringinner(parse_state):
@@ -1430,11 +1448,11 @@ def rule_stringinner(parse_state):
     if _ != ERROR:
         if parse_state.pos != len(parse_state.input_buffer):
             parse_state.pos += 1
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringend(parse_state):
@@ -1445,11 +1463,11 @@ def rule_stringend(parse_state):
     data = b'"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_charstring(parse_state):
@@ -1468,11 +1486,11 @@ def rule_charstring(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             _ = rule_quote(parse_state)
             if _ != ERROR:
-                return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_quote(parse_state):
@@ -1483,11 +1501,11 @@ def rule_quote(parse_state):
     data = b'\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_innercharstring(parse_state):
@@ -1498,11 +1516,11 @@ def rule_innercharstring(parse_state):
     data = b'\\\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1516,11 +1534,11 @@ def rule_innercharstring(parse_state):
     if _ != ERROR:
         if parse_state.pos != len(parse_state.input_buffer):
             parse_state.pos += 1
-            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
+            _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_name(parse_state):
@@ -1539,9 +1557,9 @@ def rule_name(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
-            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_char(parse_state):
@@ -1552,572 +1570,572 @@ def rule_char(parse_state):
     data = b'a'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'b'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'c'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'd'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'e'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'f'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'g'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'h'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'i'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'j'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'k'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'l'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'm'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'o'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'p'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'r'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b's'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b't'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'u'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'v'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'w'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'x'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'A'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'B'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'C'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'D'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'E'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'F'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'G'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'H'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'I'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'J'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'K'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'L'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'M'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'N'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'O'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'P'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'Q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'R'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'S'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'T'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'U'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'V'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'W'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'X'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'Y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'Z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_space(parse_state):
@@ -2134,9 +2152,9 @@ def rule_space(parse_state):
             parse_state.pos = star_pos
             break
         append_named_action(star_variables, None, _)
-    _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
+    _ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_spacechar(parse_state):
@@ -2147,22 +2165,22 @@ def rule_spacechar(parse_state):
     data = b' '
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     data = b'\n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
+        _ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 if __name__ == '__main__':
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 09bec73..aa6e934 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -21,14 +21,12 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "class Action:\n" >
-        "def __init__(self, function, variables, input_buffer, start, end):\n" >
-            "self.function = function\n"
-            "self.variables = variables\n"
-            "self.input_buffer = input_buffer\n"
-            "self.start = start\n"
-            "self.end = end\n"
-            "self.len = end-start\n"
-        <
+        "function = None\n"
+        "variables = None\n"
+        "input_buffer = None\n"
+        "start = None\n"
+        "end = None\n"
+        "len = None\n"
     <
     "\n"
     "class ChunkBuffer:\n" >
@@ -54,6 +52,17 @@ file = rule*:xs space !. -> {
         "action = None\n"
     <
     "\n"
+    "def create_action(function, variables, input_buffer, start, end):\n" >
+        "action = Action()\n"
+        "action.function = function\n"
+        "action.variables = variables\n"
+        "action.input_buffer = input_buffer\n"
+        "action.start = start\n"
+        "action.end = end\n"
+        "action.len = end-start\n"
+        "return action\n"
+    <
+    "\n"
     "def run_action(action, runtime):\n" >
         "if action.function is None:\n" >
             "if action.variables is None:\n" >
@@ -228,7 +237,7 @@ matchExprRepeat =
             <
             "append_named_action(star_variables, None, _)\n"
         <
-        "_ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
+        "_ = create_action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
     }
     | matchExprPrimitive:x -> {
         x
@@ -242,7 +251,7 @@ matchExprPrimitive =
     | '.'          -> {
         "if parse_state.pos != len(parse_state.input_buffer):\n" >
             "parse_state.pos += 1\n"
-            "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n"
+            "_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -252,7 +261,7 @@ matchExprPrimitive =
         "data = b" x "\n"
         "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n" >
             "parse_state.pos += len(data)\n"
-            "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n"
+            "_ = create_action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -270,10 +279,10 @@ action =
             <
             "\n"
         }
-        "return Action(action_" W[0] ", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+        "return create_action(action_" W[0] ", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
     }
     | -> {
-        "return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+        "return create_action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
     }
     ;
 
@@ -309,7 +318,7 @@ actionexpr =
             "\n"
         }
         "chunk_buffer = create_chunk_buffer()\n"
-        "runtime.placeholders.append((chunk_buffer, Action(placeholder_" W[1] ", variables, '', 0, 0)))\n"
+        "runtime.placeholders.append((chunk_buffer, create_action(placeholder_" W[1] ", variables, '', 0, 0)))\n"
         "append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n"
     }
     | space string:x -> {

commit e7228b0a75c9d9c72d53b142903355ab6f39adb7
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 20:56:56 2025 +0100

    Store variables and pass around variables

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 9676f50..1f240c7 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -16,9 +16,9 @@ class Runtime:
         self.W = {}
 
 class Action:
-    def __init__(self, function, variable, input_buffer, start, end):
+    def __init__(self, function, variables, input_buffer, start, end):
         self.function = function
-        self.variable = variable
+        self.variables = variables
         self.input_buffer = input_buffer
         self.start = start
         self.end = end
@@ -45,15 +45,15 @@ class Variable:
 
 def run_action(action, runtime):
     if action.function is None:
-        if action.variable is None:
+        if action.variables is None:
             append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)
         else:
-            variable = action.variable
+            variable = action.variables.pre_first.next
             while variable:
                 run_action(variable.action, runtime)
                 variable = variable.next
     else:
-        action.function(runtime, action.variable)
+        action.function(runtime, action.variables)
 
 def create_variables():
     variables = Variables()
@@ -84,8 +84,8 @@ def append_named_action(variables, name, action):
     variables.last.next = next_variable
     variables.last = next_variable
 
-def lookup_action(variable, name_to_look_for):
-    variable = variable
+def lookup_action(variables, name_to_look_for):
+    variable = variables.pre_first.next
     while variable:
         if variable.name == name_to_look_for:
             return variable.action
@@ -112,11 +112,11 @@ def render_chunk_buffer(chunk_buffer, last_char=b'\n', indent=0):
 
 ERROR = -1
 
-def action_1(runtime, variable):
+def action_1(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
 
-def action_2(runtime, variable):
+def action_2(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"import sys\n", 0)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
@@ -145,10 +145,10 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Action:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"def __init__(self, function, variable, input_buffer, start, end):\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def __init__(self, function, variables, input_buffer, start, end):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"self.function = function\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.variable = variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.variables = variables\n", 0)
     append_data(runtime.current_chunk_buffer, b"self.input_buffer = input_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b"self.start = start\n", 0)
     append_data(runtime.current_chunk_buffer, b"self.end = end\n", 0)
@@ -187,13 +187,13 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"if action.function is None:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"if action.variable is None:\n", 0)
+    append_data(runtime.current_chunk_buffer, b"if action.variables is None:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"else:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"variable = action.variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variable = action.variables.pre_first.next\n", 0)
     append_data(runtime.current_chunk_buffer, b"while variable:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"run_action(variable.action, runtime)\n", 0)
@@ -203,7 +203,7 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"else:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"action.function(runtime, action.variable)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action.function(runtime, action.variables)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
@@ -244,9 +244,9 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"variables.last = next_variable\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def lookup_action(variable, name_to_look_for):\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def lookup_action(variables, name_to_look_for):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"variable = variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variable = variables.pre_first.next\n", 0)
     append_data(runtime.current_chunk_buffer, b"while variable:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"if variable.name == name_to_look_for:\n", 0)
@@ -298,7 +298,7 @@ def action_2(runtime, variable):
     chunk_buffer = create_chunk_buffer()
     runtime.placeholder_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
-    run_action(lookup_action(variable, 'xs'), runtime)
+    run_action(lookup_action(variables, 'xs'), runtime)
     append_data(runtime.current_chunk_buffer, b"if __name__ == '__main__':\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state = ParseState(sys.stdin.buffer.read())\n", 0)
@@ -312,53 +312,53 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
 
-def action_3(runtime, variable):
+def action_3(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"def rule_", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"(parse_state):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
 
-def action_4(runtime, variable):
+def action_4(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"or_backtrack_pos = parse_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
-    run_action(lookup_action(variable, 'xs'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
+    run_action(lookup_action(variables, 'xs'), runtime)
     append_data(runtime.current_chunk_buffer, b"return ERROR\n", 0)
 
-def action_5(runtime, variable):
+def action_5(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
 
-def action_6(runtime, variable):
+def action_6(runtime, variables):
     pass
 
-def action_7(runtime, variable):
+def action_7(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"parse_state.pos = or_backtrack_pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"action_start_pos = parse_state.pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"variables = create_variables()\n", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
 
-def action_8(runtime, variable):
+def action_8(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"if _ != ERROR:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b'', -1)
 
-def action_9(runtime, variable):
+def action_9(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
 
-def action_10(runtime, variable):
+def action_10(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"nlookahead_pos = parse_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"if _ == ERROR:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"_ = lambda: None\n", 0)
@@ -369,28 +369,28 @@ def action_10(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"parse_state.pos = nlookahead_pos\n", 0)
 
-def action_11(runtime, variable):
+def action_11(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'x'), runtime)
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
 
-def action_12(runtime, variable):
+def action_12(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_named_action(variables, '", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"', _)\n", 0)
 
-def action_13(runtime, variable):
+def action_13(runtime, variables):
     pass
 
-def action_14(runtime, variable):
+def action_14(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"star_variables = create_variables()\n", 0)
     append_data(runtime.current_chunk_buffer, b"star_start_pos = parse_state.pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"while True:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"star_pos = parse_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"if _ == ERROR:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"parse_state.pos = star_pos\n", 0)
@@ -398,19 +398,19 @@ def action_14(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"append_named_action(star_variables, None, _)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"_ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
-def action_15(runtime, variable):
+def action_15(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
 
-def action_16(runtime, variable):
+def action_16(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"_ = rule_", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"(parse_state)\n", 0)
 
-def action_17(runtime, variable):
+def action_17(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -422,10 +422,10 @@ def action_17(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
 
-def action_18(runtime, variable):
+def action_18(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"data = b", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -437,7 +437,7 @@ def action_18(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
 
-def action_19(runtime, variable):
+def action_19(runtime, variables):
     pass
     runtime.W[0] = inc(runtime.W.get(0, 0), 1)
     last_chunk_buffer = runtime.current_chunk_buffer
@@ -445,59 +445,59 @@ def action_19(runtime, variable):
     runtime.current_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b"def action_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b"(runtime, variable):\n", 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime, variables):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"pass\n", 0)
-    run_action(lookup_action(variable, 'xs'), runtime)
+    run_action(lookup_action(variables, 'xs'), runtime)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
     append_data(runtime.current_chunk_buffer, b"return Action(action_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b", variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
-def action_20(runtime, variable):
+def action_20(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
-def action_21(runtime, variable):
+def action_21(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = runtime.", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"_chunk_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
-    run_action(lookup_action(variable, 'ys'), runtime)
+    run_action(lookup_action(variables, 'ys'), runtime)
     append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = last_chunk_buffer\n", 0)
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.namedBuffers_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b"self.", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"_chunk_buffer = None\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
 
-def action_22(runtime, variable):
+def action_22(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"_chunk_buffer = chunk_buffer\n", 0)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
-def action_23(runtime, variable):
+def action_23(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, str(", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b").encode('ascii'), 0)\n", 0)
 
-def action_24(runtime, variable):
+def action_24(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"run_action(lookup_action(variable, '", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    append_data(runtime.current_chunk_buffer, b"run_action(lookup_action(variables, '", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"'), runtime)\n", 0)
 
-def action_25(runtime, variable):
+def action_25(runtime, variables):
     pass
     runtime.W[1] = inc(runtime.W.get(1, 0), 1)
     last_chunk_buffer = runtime.current_chunk_buffer
@@ -505,81 +505,81 @@ def action_25(runtime, variable):
     runtime.current_chunk_buffer = chunk_buffer
     append_data(runtime.current_chunk_buffer, b"def placeholder_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b"(runtime, variable):\n", 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime, variables):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"pass\n", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((chunk_buffer, Action(placeholder_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b", variable, '', 0, 0)))\n", 0)
+    append_data(runtime.current_chunk_buffer, b", variables, '', 0, 0)))\n", 0)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
-def action_26(runtime, variable):
+def action_26(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
 
-def action_27(runtime, variable):
+def action_27(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"runtime.W[", 0)
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b"] = ", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"(runtime.W.get(", 0)
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b", 0), ", 0)
-    run_action(lookup_action(variable, 'z'), runtime)
+    run_action(lookup_action(variables, 'z'), runtime)
     append_data(runtime.current_chunk_buffer, b")\n", 0)
 
-def action_28(runtime, variable):
+def action_28(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 1)\n", 0)
-    run_action(lookup_action(variable, 'xs'), runtime)
+    run_action(lookup_action(variables, 'xs'), runtime)
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', -1)\n", 0)
 
-def action_29(runtime, variable):
+def action_29(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
 
-def action_30(runtime, variable):
+def action_30(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"*", 0)
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
 
-def action_31(runtime, variable):
+def action_31(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"runtime.W.get(", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b", 0)", 0)
 
-def action_32(runtime, variable):
+def action_32(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"(runtime.W.get(", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b", 0)-", 0)
-    run_action(lookup_action(variable, 'y'), runtime)
+    run_action(lookup_action(variables, 'y'), runtime)
     append_data(runtime.current_chunk_buffer, b")", 0)
 
-def action_33(runtime, variable):
+def action_33(runtime, variables):
     pass
-    append_data(runtime.current_chunk_buffer, b"lookup_action(variable, '", 0)
-    run_action(lookup_action(variable, 'x'), runtime)
+    append_data(runtime.current_chunk_buffer, b"lookup_action(variables, '", 0)
+    run_action(lookup_action(variables, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"')", 0)
-    run_action(lookup_action(variable, 'xs'), runtime)
+    run_action(lookup_action(variables, 'xs'), runtime)
 
-def action_34(runtime, variable):
+def action_34(runtime, variables):
     pass
-    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variables, 'x'), runtime)
 
-def action_35(runtime, variable):
+def action_35(runtime, variables):
     pass
     append_data(runtime.current_chunk_buffer, b"'", 0)
 
@@ -591,7 +591,7 @@ def rule_main(parse_state):
     _ = rule_file(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_1, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_1, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_file(parse_state):
@@ -608,7 +608,7 @@ def rule_file(parse_state):
             parse_state.pos = star_pos
             break
         append_named_action(star_variables, None, _)
-    _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+    _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
     append_named_action(variables, 'xs', _)
     if _ != ERROR:
         _ = rule_space(parse_state)
@@ -625,7 +625,7 @@ def rule_file(parse_state):
                 _ = ERROR
             parse_state.pos = nlookahead_pos
             if _ != ERROR:
-                return Action(action_2, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_2, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_rule(parse_state):
@@ -661,7 +661,7 @@ def rule_rule(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_3, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return Action(action_3, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_ors(parse_state):
@@ -683,10 +683,10 @@ def rule_ors(parse_state):
                     parse_state.pos = star_pos
                     break
                 append_named_action(star_variables, None, _)
-            _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
             append_named_action(variables, 'xs', _)
             if _ != ERROR:
-                return Action(action_4, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_4, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_restorcase(parse_state):
@@ -699,7 +699,7 @@ def rule_restorcase(parse_state):
         _ = rule_orcase(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_5, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_5, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_maybeorbar(parse_state):
@@ -713,7 +713,7 @@ def rule_maybeorbar(parse_state):
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
-    return Action(action_6, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return Action(action_6, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_orbar(parse_state):
@@ -741,7 +741,7 @@ def rule_orcase(parse_state):
     _ = rule_matchAnd(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_7, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_7, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAnd(parse_state):
@@ -757,14 +757,14 @@ def rule_matchAnd(parse_state):
             _ = rule_matchAnd(parse_state)
             append_named_action(variables, 'y', _)
             if _ != ERROR:
-                return Action(action_8, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_8, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_action(parse_state)
     append_named_action(variables, 'y', _)
     if _ != ERROR:
-        return Action(action_9, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_9, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExpr(parse_state):
@@ -782,7 +782,7 @@ def rule_matchExpr(parse_state):
         _ = rule_matchExprPrimitive(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_10, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_10, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -792,7 +792,7 @@ def rule_matchExpr(parse_state):
         _ = rule_matchAssign(parse_state)
         append_named_action(variables, 'y', _)
         if _ != ERROR:
-            return Action(action_11, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_11, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAssign(parse_state):
@@ -810,11 +810,11 @@ def rule_matchAssign(parse_state):
         _ = rule_name(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_12, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_12, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
-    return Action(action_13, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return Action(action_13, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprRepeat(parse_state):
@@ -832,14 +832,14 @@ def rule_matchExprRepeat(parse_state):
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(action_14, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_14, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_matchExprPrimitive(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_15, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_15, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprPrimitive(parse_state):
@@ -850,7 +850,7 @@ def rule_matchExprPrimitive(parse_state):
     _ = rule_name(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_16, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_16, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -861,14 +861,14 @@ def rule_matchExprPrimitive(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(action_17, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_17, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
     _ = rule_charstring(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_18, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_18, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_action(parse_state):
@@ -903,7 +903,7 @@ def rule_action(parse_state):
                             parse_state.pos = star_pos
                             break
                         append_named_action(star_variables, None, _)
-                    _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                    _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
                     append_named_action(variables, 'xs', _)
                     if _ != ERROR:
                         _ = rule_space(parse_state)
@@ -915,11 +915,11 @@ def rule_action(parse_state):
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(action_19, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return Action(action_19, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
-    return Action(action_20, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    return Action(action_20, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionexpr(parse_state):
@@ -957,7 +957,7 @@ def rule_actionexpr(parse_state):
                                 parse_state.pos = star_pos
                                 break
                             append_named_action(star_variables, None, _)
-                        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
                         append_named_action(variables, 'ys', _)
                         if _ != ERROR:
                             _ = rule_space(parse_state)
@@ -969,7 +969,7 @@ def rule_actionexpr(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_21, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return Action(action_21, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -985,7 +985,7 @@ def rule_actionexpr(parse_state):
             _ = rule_name(parse_state)
             append_named_action(variables, 'x', _)
             if _ != ERROR:
-                return Action(action_22, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_22, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -994,7 +994,7 @@ def rule_actionexpr(parse_state):
         _ = rule_expr(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_23, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_23, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1003,7 +1003,7 @@ def rule_actionexpr(parse_state):
         _ = rule_name(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_24, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_24, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1012,7 +1012,7 @@ def rule_actionexpr(parse_state):
         _ = rule_placeholder(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_25, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_25, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1021,7 +1021,7 @@ def rule_actionexpr(parse_state):
         _ = rule_string(parse_state)
         append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_26, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_26, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1064,7 +1064,7 @@ def rule_actionexpr(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_27, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return Action(action_27, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1086,7 +1086,7 @@ def rule_actionexpr(parse_state):
                     parse_state.pos = star_pos
                     break
                 append_named_action(star_variables, None, _)
-            _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
             append_named_action(variables, 'xs', _)
             if _ != ERROR:
                 _ = rule_space(parse_state)
@@ -1098,7 +1098,7 @@ def rule_actionexpr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(action_28, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return Action(action_28, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionPrimitiveExpression(parse_state):
@@ -1109,7 +1109,7 @@ def rule_actionPrimitiveExpression(parse_state):
     _ = rule_dotname(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_29, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_29, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1268,7 +1268,7 @@ def rule_placeholder(parse_state):
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(action_30, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return Action(action_30, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_expr(parse_state):
@@ -1279,7 +1279,7 @@ def rule_expr(parse_state):
     _ = rule_wvar(parse_state)
     append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_31, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_31, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1310,7 +1310,7 @@ def rule_expr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(action_32, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return Action(action_32, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_string(parse_state):
@@ -1334,7 +1334,7 @@ def rule_string(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             data = b'"'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1363,10 +1363,10 @@ def rule_dotname(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         append_named_action(variables, 'xs', _)
         if _ != ERROR:
-            return Action(action_33, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_33, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_nextname(parse_state):
@@ -1412,7 +1412,7 @@ def rule_wvar(parse_state):
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(action_34, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_34, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringinner(parse_state):
@@ -1468,7 +1468,7 @@ def rule_charstring(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             _ = rule_quote(parse_state)
             if _ != ERROR:
@@ -1502,7 +1502,7 @@ def rule_innercharstring(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(action_35, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_35, variables, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     variables = create_variables()
@@ -1539,7 +1539,7 @@ def rule_name(parse_state):
                 parse_state.pos = star_pos
                 break
             append_named_action(star_variables, None, _)
-        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
@@ -2134,7 +2134,7 @@ def rule_space(parse_state):
             parse_state.pos = star_pos
             break
         append_named_action(star_variables, None, _)
-    _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+    _ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)
     if _ != ERROR:
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 832541b..09bec73 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -21,9 +21,9 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "class Action:\n" >
-        "def __init__(self, function, variable, input_buffer, start, end):\n" >
+        "def __init__(self, function, variables, input_buffer, start, end):\n" >
             "self.function = function\n"
-            "self.variable = variable\n"
+            "self.variables = variables\n"
             "self.input_buffer = input_buffer\n"
             "self.start = start\n"
             "self.end = end\n"
@@ -56,11 +56,11 @@ file = rule*:xs space !. -> {
     "\n"
     "def run_action(action, runtime):\n" >
         "if action.function is None:\n" >
-            "if action.variable is None:\n" >
+            "if action.variables is None:\n" >
                 "append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)\n"
             <
             "else:\n" >
-                "variable = action.variable\n"
+                "variable = action.variables.pre_first.next\n"
                 "while variable:\n" >
                     "run_action(variable.action, runtime)\n"
                     "variable = variable.next\n"
@@ -68,7 +68,7 @@ file = rule*:xs space !. -> {
             <
         <
         "else:\n" >
-            "action.function(runtime, action.variable)\n"
+            "action.function(runtime, action.variables)\n"
         <
     <
     "\n"
@@ -105,8 +105,8 @@ file = rule*:xs space !. -> {
         "variables.last = next_variable\n"
     <
     "\n"
-    "def lookup_action(variable, name_to_look_for):\n" >
-        "variable = variable\n"
+    "def lookup_action(variables, name_to_look_for):\n" >
+        "variable = variables.pre_first.next\n"
         "while variable:\n" >
             "if variable.name == name_to_look_for:\n" >
                 "return variable.action\n"
@@ -228,7 +228,7 @@ matchExprRepeat =
             <
             "append_named_action(star_variables, None, _)\n"
         <
-        "_ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
+        "_ = Action(None, star_variables, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
     }
     | matchExprPrimitive:x -> {
         x
@@ -264,13 +264,13 @@ action =
     | space '->' space '{' actionexpr*:xs space '}' -> {
         #inc(W[0] 1)
         >action {
-            "def action_" W[0] "(runtime, variable):\n" >
+            "def action_" W[0] "(runtime, variables):\n" >
                 "pass\n"
                 xs
             <
             "\n"
         }
-        "return Action(action_" W[0] ", variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+        "return Action(action_" W[0] ", variables, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
     }
     | -> {
         "return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
@@ -297,19 +297,19 @@ actionexpr =
         "append_data(runtime.current_chunk_buffer, str(" x ").encode('ascii'), 0)\n"
     }
     | space name:x -> {
-        "run_action(lookup_action(variable, '" x "'), runtime)\n"
+        "run_action(lookup_action(variables, '" x "'), runtime)\n"
     }
     | space placeholder:x -> {
         #inc(W[1] 1)
         >placeholder {
-            "def placeholder_" W[1] "(runtime, variable):\n" >
+            "def placeholder_" W[1] "(runtime, variables):\n" >
                 "pass\n"
                 x
             <
             "\n"
         }
         "chunk_buffer = create_chunk_buffer()\n"
-        "runtime.placeholders.append((chunk_buffer, Action(placeholder_" W[1] ", variable, '', 0, 0)))\n"
+        "runtime.placeholders.append((chunk_buffer, Action(placeholder_" W[1] ", variables, '', 0, 0)))\n"
         "append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n"
     }
     | space string:x -> {
@@ -361,7 +361,7 @@ expr =
 string = '"' stringinner* '"';
 
 dotname = name:x nextname*:xs -> {
-    "lookup_action(variable, '" x "')" xs
+    "lookup_action(variables, '" x "')" xs
 };
 
 nextname = '.' name;

commit 03fde4a03b550359d7a4baede0db5970dc7a9e47
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 20:54:05 2025 +0100

    Get rid of old append_named_action

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 23c4f93..9676f50 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -76,7 +76,7 @@ def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):
     chunk_buffer.last.next = chunk
     chunk_buffer.last = chunk
 
-def append_named_action2(variables, name, action):
+def append_named_action(variables, name, action):
     next_variable = Variable()
     next_variable.next = None
     next_variable.name = name
@@ -84,14 +84,6 @@ def append_named_action2(variables, name, action):
     variables.last.next = next_variable
     variables.last = next_variable
 
-def append_named_action(variable, name, action):
-    next_variable = Variable()
-    next_variable.next = variable.next
-    next_variable.name = name
-    next_variable.action = action
-    variable.next = next_variable
-    return next_variable
-
 def lookup_action(variable, name_to_look_for):
     variable = variable
     while variable:
@@ -242,7 +234,7 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def append_named_action2(variables, name, action):\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def append_named_action(variables, name, action):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"next_variable = Variable()\n", 0)
     append_data(runtime.current_chunk_buffer, b"next_variable.next = None\n", 0)
@@ -252,16 +244,6 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"variables.last = next_variable\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"def append_named_action(variable, name, action):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"next_variable = Variable()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.next = variable.next\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.name = name\n", 0)
-    append_data(runtime.current_chunk_buffer, b"next_variable.action = action\n", 0)
-    append_data(runtime.current_chunk_buffer, b"variable.next = next_variable\n", 0)
-    append_data(runtime.current_chunk_buffer, b"return next_variable\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def lookup_action(variable, name_to_look_for):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"variable = variable\n", 0)
@@ -358,8 +340,7 @@ def action_7(runtime, variable):
     pass
     append_data(runtime.current_chunk_buffer, b"parse_state.pos = or_backtrack_pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"action_start_pos = parse_state.pos\n", 0)
-    append_data(runtime.current_chunk_buffer, b"pre_first_variable = Variable()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"last_variable = pre_first_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables = create_variables()\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
 
 def action_8(runtime, variable):
@@ -395,7 +376,7 @@ def action_11(runtime, variable):
 
 def action_12(runtime, variable):
     pass
-    append_data(runtime.current_chunk_buffer, b"last_variable = append_named_action(last_variable, '", 0)
+    append_data(runtime.current_chunk_buffer, b"append_named_action(variables, '", 0)
     run_action(lookup_action(variable, 'x'), runtime)
     append_data(runtime.current_chunk_buffer, b"', _)\n", 0)
 
@@ -404,7 +385,7 @@ def action_13(runtime, variable):
 
 def action_14(runtime, variable):
     pass
-    append_data(runtime.current_chunk_buffer, b"variables = create_variables()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"star_variables = create_variables()\n", 0)
     append_data(runtime.current_chunk_buffer, b"star_start_pos = parse_state.pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"while True:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -415,9 +396,9 @@ def action_14(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"parse_state.pos = star_pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"break\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"append_named_action2(variables, None, _)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_named_action(star_variables, None, _)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"_ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variable):
     pass
@@ -473,7 +454,7 @@ def action_19(runtime, variable):
     runtime.current_chunk_buffer = last_chunk_buffer
     append_data(runtime.current_chunk_buffer, b"return Action(action_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
-    append_data(runtime.current_chunk_buffer, b", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b", variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variable):
     pass
@@ -606,21 +587,19 @@ def rule_main(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_file(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_1, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_1, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_file(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
     variables = create_variables()
+    star_variables = create_variables()
     star_start_pos = parse_state.pos
     while True:
         star_pos = parse_state.pos
@@ -628,9 +607,9 @@ def rule_file(parse_state):
         if _ == ERROR:
             parse_state.pos = star_pos
             break
-        append_named_action2(variables, None, _)
-    _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
-    last_variable = append_named_action(last_variable, 'xs', _)
+        append_named_action(star_variables, None, _)
+    _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+    append_named_action(variables, 'xs', _)
     if _ != ERROR:
         _ = rule_space(parse_state)
         if _ != ERROR:
@@ -646,19 +625,18 @@ def rule_file(parse_state):
                 _ = ERROR
             parse_state.pos = nlookahead_pos
             if _ != ERROR:
-                return Action(action_2, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_2, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_rule(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         _ = rule_name(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
             _ = rule_space(parse_state)
             if _ != ERROR:
@@ -672,7 +650,7 @@ def rule_rule(parse_state):
                     _ = rule_space(parse_state)
                     if _ != ERROR:
                         _ = rule_ors(parse_state)
-                        last_variable = append_named_action(last_variable, 'y', _)
+                        append_named_action(variables, 'y', _)
                         if _ != ERROR:
                             _ = rule_space(parse_state)
                             if _ != ERROR:
@@ -683,21 +661,20 @@ def rule_rule(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_3, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return Action(action_3, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_ors(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_maybeorbar(parse_state)
     if _ != ERROR:
         _ = rule_orcase(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            variables = create_variables()
+            star_variables = create_variables()
             star_start_pos = parse_state.pos
             while True:
                 star_pos = parse_state.pos
@@ -705,49 +682,45 @@ def rule_ors(parse_state):
                 if _ == ERROR:
                     parse_state.pos = star_pos
                     break
-                append_named_action2(variables, None, _)
-            _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
-            last_variable = append_named_action(last_variable, 'xs', _)
+                append_named_action(star_variables, None, _)
+            _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action(variables, 'xs', _)
             if _ != ERROR:
-                return Action(action_4, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_4, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_restorcase(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_orbar(parse_state)
     if _ != ERROR:
         _ = rule_orcase(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_5, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_5, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_maybeorbar(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_orbar(parse_state)
     if _ != ERROR:
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
-    return Action(action_6, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    variables = create_variables()
+    return Action(action_6, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_orbar(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         data = b'|'
@@ -764,45 +737,41 @@ def rule_orcase(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_matchAnd(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_7, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_7, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAnd(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         _ = rule_matchExpr(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
             _ = rule_matchAnd(parse_state)
-            last_variable = append_named_action(last_variable, 'y', _)
+            append_named_action(variables, 'y', _)
             if _ != ERROR:
-                return Action(action_8, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_8, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_action(parse_state)
-    last_variable = append_named_action(last_variable, 'y', _)
+    append_named_action(variables, 'y', _)
     if _ != ERROR:
-        return Action(action_9, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_9, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExpr(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'!'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -811,28 +780,26 @@ def rule_matchExpr(parse_state):
         _ = ERROR
     if _ != ERROR:
         _ = rule_matchExprPrimitive(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_10, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_10, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_matchExprRepeat(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
         _ = rule_matchAssign(parse_state)
-        last_variable = append_named_action(last_variable, 'y', _)
+        append_named_action(variables, 'y', _)
         if _ != ERROR:
-            return Action(action_11, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_11, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAssign(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b':'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -841,24 +808,22 @@ def rule_matchAssign(parse_state):
         _ = ERROR
     if _ != ERROR:
         _ = rule_name(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_12, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_12, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
-    return Action(action_13, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    variables = create_variables()
+    return Action(action_13, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprRepeat(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_matchExprPrimitive(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
         data = b'*'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -867,31 +832,28 @@ def rule_matchExprRepeat(parse_state):
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(action_14, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_14, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_matchExprPrimitive(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_15, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_15, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprPrimitive(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_name(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_16, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_16, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -899,23 +861,21 @@ def rule_matchExprPrimitive(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(action_17, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_17, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_charstring(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_18, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_18, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_action(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         data = b'->'
@@ -934,7 +894,7 @@ def rule_action(parse_state):
                 else:
                     _ = ERROR
                 if _ != ERROR:
-                    variables = create_variables()
+                    star_variables = create_variables()
                     star_start_pos = parse_state.pos
                     while True:
                         star_pos = parse_state.pos
@@ -942,9 +902,9 @@ def rule_action(parse_state):
                         if _ == ERROR:
                             parse_state.pos = star_pos
                             break
-                        append_named_action2(variables, None, _)
-                    _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
-                    last_variable = append_named_action(last_variable, 'xs', _)
+                        append_named_action(star_variables, None, _)
+                    _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                    append_named_action(variables, 'xs', _)
                     if _ != ERROR:
                         _ = rule_space(parse_state)
                         if _ != ERROR:
@@ -955,20 +915,18 @@ def rule_action(parse_state):
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(action_19, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return Action(action_19, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
-    return Action(action_20, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+    variables = create_variables()
+    return Action(action_20, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionexpr(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         data = b'>'
@@ -979,7 +937,7 @@ def rule_actionexpr(parse_state):
             _ = ERROR
         if _ != ERROR:
             _ = rule_name(parse_state)
-            last_variable = append_named_action(last_variable, 'x', _)
+            append_named_action(variables, 'x', _)
             if _ != ERROR:
                 _ = rule_space(parse_state)
                 if _ != ERROR:
@@ -990,7 +948,7 @@ def rule_actionexpr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        variables = create_variables()
+                        star_variables = create_variables()
                         star_start_pos = parse_state.pos
                         while True:
                             star_pos = parse_state.pos
@@ -998,9 +956,9 @@ def rule_actionexpr(parse_state):
                             if _ == ERROR:
                                 parse_state.pos = star_pos
                                 break
-                            append_named_action2(variables, None, _)
-                        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
-                        last_variable = append_named_action(last_variable, 'ys', _)
+                            append_named_action(star_variables, None, _)
+                        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                        append_named_action(variables, 'ys', _)
                         if _ != ERROR:
                             _ = rule_space(parse_state)
                             if _ != ERROR:
@@ -1011,11 +969,10 @@ def rule_actionexpr(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_21, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return Action(action_21, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         data = b'<'
@@ -1026,53 +983,48 @@ def rule_actionexpr(parse_state):
             _ = ERROR
         if _ != ERROR:
             _ = rule_name(parse_state)
-            last_variable = append_named_action(last_variable, 'x', _)
+            append_named_action(variables, 'x', _)
             if _ != ERROR:
-                return Action(action_22, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_22, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         _ = rule_expr(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_23, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_23, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         _ = rule_name(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_24, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_24, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         _ = rule_placeholder(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_25, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_25, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         _ = rule_string(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
-            return Action(action_26, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_26, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         data = b'#'
@@ -1083,7 +1035,7 @@ def rule_actionexpr(parse_state):
             _ = ERROR
         if _ != ERROR:
             _ = rule_name(parse_state)
-            last_variable = append_named_action(last_variable, 'x', _)
+            append_named_action(variables, 'x', _)
             if _ != ERROR:
                 data = b'('
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1093,7 +1045,7 @@ def rule_actionexpr(parse_state):
                     _ = ERROR
                 if _ != ERROR:
                     _ = rule_wvar(parse_state)
-                    last_variable = append_named_action(last_variable, 'y', _)
+                    append_named_action(variables, 'y', _)
                     if _ != ERROR:
                         data = b' '
                         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1103,7 +1055,7 @@ def rule_actionexpr(parse_state):
                             _ = ERROR
                         if _ != ERROR:
                             _ = rule_actionPrimitiveExpression(parse_state)
-                            last_variable = append_named_action(last_variable, 'z', _)
+                            append_named_action(variables, 'z', _)
                             if _ != ERROR:
                                 data = b')'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1112,11 +1064,10 @@ def rule_actionexpr(parse_state):
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(action_27, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                    return Action(action_27, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_space(parse_state)
     if _ != ERROR:
         data = b'>'
@@ -1126,7 +1077,7 @@ def rule_actionexpr(parse_state):
         else:
             _ = ERROR
         if _ != ERROR:
-            variables = create_variables()
+            star_variables = create_variables()
             star_start_pos = parse_state.pos
             while True:
                 star_pos = parse_state.pos
@@ -1134,9 +1085,9 @@ def rule_actionexpr(parse_state):
                 if _ == ERROR:
                     parse_state.pos = star_pos
                     break
-                append_named_action2(variables, None, _)
-            _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
-            last_variable = append_named_action(last_variable, 'xs', _)
+                append_named_action(star_variables, None, _)
+            _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action(variables, 'xs', _)
             if _ != ERROR:
                 _ = rule_space(parse_state)
                 if _ != ERROR:
@@ -1147,23 +1098,21 @@ def rule_actionexpr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(action_28, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return Action(action_28, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionPrimitiveExpression(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_dotname(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_29, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_29, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_digit(parse_state)
     if _ != ERROR:
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
@@ -1173,8 +1122,7 @@ def rule_digit(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'0'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1185,8 +1133,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'1'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1197,8 +1144,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'2'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1209,8 +1155,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'3'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1221,8 +1166,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'4'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1233,8 +1177,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'5'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1245,8 +1188,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'6'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1257,8 +1199,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'7'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1269,8 +1210,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'8'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1281,8 +1221,7 @@ def rule_digit(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'9'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1297,8 +1236,7 @@ def rule_placeholder(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'{'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1309,7 +1247,7 @@ def rule_placeholder(parse_state):
         _ = rule_space(parse_state)
         if _ != ERROR:
             _ = rule_string(parse_state)
-            last_variable = append_named_action(last_variable, 'x', _)
+            append_named_action(variables, 'x', _)
             if _ != ERROR:
                 data = b'*'
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1319,7 +1257,7 @@ def rule_placeholder(parse_state):
                     _ = ERROR
                 if _ != ERROR:
                     _ = rule_expr(parse_state)
-                    last_variable = append_named_action(last_variable, 'y', _)
+                    append_named_action(variables, 'y', _)
                     if _ != ERROR:
                         _ = rule_space(parse_state)
                         if _ != ERROR:
@@ -1330,23 +1268,21 @@ def rule_placeholder(parse_state):
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(action_30, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                                return Action(action_30, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_expr(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_wvar(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        return Action(action_31, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_31, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'('
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1355,7 +1291,7 @@ def rule_expr(parse_state):
         _ = ERROR
     if _ != ERROR:
         _ = rule_wvar(parse_state)
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
             data = b'-'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1365,7 +1301,7 @@ def rule_expr(parse_state):
                 _ = ERROR
             if _ != ERROR:
                 _ = rule_dotname(parse_state)
-                last_variable = append_named_action(last_variable, 'y', _)
+                append_named_action(variables, 'y', _)
                 if _ != ERROR:
                     data = b')'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1374,15 +1310,14 @@ def rule_expr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(action_32, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                        return Action(action_32, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_string(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1390,7 +1325,7 @@ def rule_string(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        variables = create_variables()
+        star_variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1398,8 +1333,8 @@ def rule_string(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            append_named_action2(variables, None, _)
-        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action(star_variables, None, _)
+        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             data = b'"'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1415,12 +1350,11 @@ def rule_dotname(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_name(parse_state)
-    last_variable = append_named_action(last_variable, 'x', _)
+    append_named_action(variables, 'x', _)
     if _ != ERROR:
-        variables = create_variables()
+        star_variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1428,19 +1362,18 @@ def rule_dotname(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            append_named_action2(variables, None, _)
-        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
-        last_variable = append_named_action(last_variable, 'xs', _)
+            append_named_action(star_variables, None, _)
+        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        append_named_action(variables, 'xs', _)
         if _ != ERROR:
-            return Action(action_33, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+            return Action(action_33, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_nextname(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1457,8 +1390,7 @@ def rule_wvar(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'W['
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1471,7 +1403,7 @@ def rule_wvar(parse_state):
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
-        last_variable = append_named_action(last_variable, 'x', _)
+        append_named_action(variables, 'x', _)
         if _ != ERROR:
             data = b']'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1480,15 +1412,14 @@ def rule_wvar(parse_state):
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(action_34, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+                return Action(action_34, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringinner(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     nlookahead_pos = parse_state.pos
     _ = rule_stringend(parse_state)
     if _ == ERROR:
@@ -1510,8 +1441,7 @@ def rule_stringend(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1526,11 +1456,10 @@ def rule_charstring(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_quote(parse_state)
     if _ != ERROR:
-        variables = create_variables()
+        star_variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1538,8 +1467,8 @@ def rule_charstring(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            append_named_action2(variables, None, _)
-        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action(star_variables, None, _)
+        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             _ = rule_quote(parse_state)
             if _ != ERROR:
@@ -1550,8 +1479,7 @@ def rule_quote(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1566,8 +1494,7 @@ def rule_innercharstring(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'\\\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1575,11 +1502,10 @@ def rule_innercharstring(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(action_35, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
+        return Action(action_35, variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     nlookahead_pos = parse_state.pos
     _ = rule_quote(parse_state)
     if _ == ERROR:
@@ -1601,11 +1527,10 @@ def rule_name(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     _ = rule_char(parse_state)
     if _ != ERROR:
-        variables = create_variables()
+        star_variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1613,8 +1538,8 @@ def rule_name(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            append_named_action2(variables, None, _)
-        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action(star_variables, None, _)
+        _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
@@ -1623,8 +1548,7 @@ def rule_char(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'a'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1635,8 +1559,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'b'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1647,8 +1570,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'c'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1659,8 +1581,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'd'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1671,8 +1592,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'e'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1683,8 +1603,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'f'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1695,8 +1614,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'g'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1707,8 +1625,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'h'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1719,8 +1636,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'i'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1731,8 +1647,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'j'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1743,8 +1658,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'k'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1755,8 +1669,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'l'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1767,8 +1680,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'm'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1779,8 +1691,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1791,8 +1702,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'o'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1803,8 +1713,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'p'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1815,8 +1724,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1827,8 +1735,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'r'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1839,8 +1746,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b's'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1851,8 +1757,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b't'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1863,8 +1768,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'u'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1875,8 +1779,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'v'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1887,8 +1790,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'w'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1899,8 +1801,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'x'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1911,8 +1812,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1923,8 +1823,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1935,8 +1834,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'A'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1947,8 +1845,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'B'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1959,8 +1856,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'C'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1971,8 +1867,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'D'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1983,8 +1878,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'E'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -1995,8 +1889,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'F'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2007,8 +1900,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'G'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2019,8 +1911,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'H'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2031,8 +1922,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'I'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2043,8 +1933,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'J'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2055,8 +1944,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'K'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2067,8 +1955,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'L'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2079,8 +1966,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'M'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2091,8 +1977,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'N'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2103,8 +1988,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'O'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2115,8 +1999,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'P'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2127,8 +2010,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'Q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2139,8 +2021,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'R'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2151,8 +2032,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'S'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2163,8 +2043,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'T'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2175,8 +2054,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'U'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2187,8 +2065,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'V'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2199,8 +2076,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'W'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2211,8 +2087,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'X'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2223,8 +2098,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'Y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2235,8 +2109,7 @@ def rule_char(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'Z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2251,9 +2124,8 @@ def rule_space(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
     variables = create_variables()
+    star_variables = create_variables()
     star_start_pos = parse_state.pos
     while True:
         star_pos = parse_state.pos
@@ -2261,8 +2133,8 @@ def rule_space(parse_state):
         if _ == ERROR:
             parse_state.pos = star_pos
             break
-        append_named_action2(variables, None, _)
-    _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        append_named_action(star_variables, None, _)
+    _ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
     if _ != ERROR:
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
@@ -2271,8 +2143,7 @@ def rule_spacechar(parse_state):
     or_backtrack_pos = parse_state.pos
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b' '
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
@@ -2283,8 +2154,7 @@ def rule_spacechar(parse_state):
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
-    pre_first_variable = Variable()
-    last_variable = pre_first_variable
+    variables = create_variables()
     data = b'\n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index dd8c2cf..832541b 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -96,7 +96,7 @@ file = rule*:xs space !. -> {
         "chunk_buffer.last = chunk\n"
     <
     "\n"
-    "def append_named_action2(variables, name, action):\n" >
+    "def append_named_action(variables, name, action):\n" >
         "next_variable = Variable()\n"
         "next_variable.next = None\n"
         "next_variable.name = name\n"
@@ -105,15 +105,6 @@ file = rule*:xs space !. -> {
         "variables.last = next_variable\n"
     <
     "\n"
-    "def append_named_action(variable, name, action):\n" >
-        "next_variable = Variable()\n"
-        "next_variable.next = variable.next\n"
-        "next_variable.name = name\n"
-        "next_variable.action = action\n"
-        "variable.next = next_variable\n"
-        "return next_variable\n"
-    <
-    "\n"
     "def lookup_action(variable, name_to_look_for):\n" >
         "variable = variable\n"
         "while variable:\n" >
@@ -190,8 +181,7 @@ orbar = space '|';
 orcase = matchAnd:x -> {
     "parse_state.pos = or_backtrack_pos\n"
     "action_start_pos = parse_state.pos\n"
-    "pre_first_variable = Variable()\n"
-    "last_variable = pre_first_variable\n"
+    "variables = create_variables()\n"
     x
 };
 
@@ -221,7 +211,7 @@ matchExpr =
     ;
 
 matchAssign =
-    | ':' name:x -> { "last_variable = append_named_action(last_variable, '" x "', _)\n" }
+    | ':' name:x -> { "append_named_action(variables, '" x "', _)\n" }
     |            -> {}
     ;
 
@@ -236,7 +226,7 @@ matchExprRepeat =
                 "parse_state.pos = star_pos\n"
                 "break\n"
             <
-            "append_named_action2(star_variables, None, _)\n"
+            "append_named_action(star_variables, None, _)\n"
         <
         "_ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
     }
@@ -280,7 +270,7 @@ action =
             <
             "\n"
         }
-        "return Action(action_" W[0] ", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
+        "return Action(action_" W[0] ", variables.pre_first.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
     }
     | -> {
         "return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"

commit 9f6e0eca0fb48138b2ea4cc7bcbe43b2a26eb325
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 20:50:56 2025 +0100

    Refactor towards Variables

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 94caae6..23c4f93 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -34,11 +34,14 @@ class Chunk:
     chunk_buffer = None
     indentation_delta = None
 
+class Variables:
+    pre_first = None
+    last = None
+
 class Variable:
-    def __init__(self):
-        self.next = None
-        self.name = None
-        self.action = None
+    next = None
+    name = None
+    action = None
 
 def run_action(action, runtime):
     if action.function is None:
@@ -52,6 +55,12 @@ def run_action(action, runtime):
     else:
         action.function(runtime, action.variable)
 
+def create_variables():
+    variables = Variables()
+    variables.pre_first = Variable()
+    variables.last = variables.pre_first
+    return variables
+
 def create_chunk_buffer():
     chunk_buffer = ChunkBuffer()
     chunk_buffer.pre_first = Chunk()
@@ -67,6 +76,14 @@ def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):
     chunk_buffer.last.next = chunk
     chunk_buffer.last = chunk
 
+def append_named_action2(variables, name, action):
+    next_variable = Variable()
+    next_variable.next = None
+    next_variable.name = name
+    next_variable.action = action
+    variables.last.next = next_variable
+    variables.last = next_variable
+
 def append_named_action(variable, name, action):
     next_variable = Variable()
     next_variable.next = variable.next
@@ -161,14 +178,17 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"indentation_delta = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    append_data(runtime.current_chunk_buffer, b"class Variable:\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Variables:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"self.next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.name = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.action = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Variable:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"name = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def run_action(action, runtime):\n", 0)
@@ -195,6 +215,14 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_variables():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"variables = Variables()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables.pre_first = Variable()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables.last = variables.pre_first\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return variables\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def create_chunk_buffer():\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"chunk_buffer = ChunkBuffer()\n", 0)
@@ -214,6 +242,16 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def append_named_action2(variables, name, action):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"next_variable = Variable()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.name = name\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.action = action\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables.last.next = next_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables.last = next_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def append_named_action(variable, name, action):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"next_variable = Variable()\n", 0)
@@ -366,8 +404,7 @@ def action_13(runtime, variable):
 
 def action_14(runtime, variable):
     pass
-    append_data(runtime.current_chunk_buffer, b"star_pre_first = Variable()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"star_last = star_pre_first\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variables = create_variables()\n", 0)
     append_data(runtime.current_chunk_buffer, b"star_start_pos = parse_state.pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"while True:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -378,9 +415,9 @@ def action_14(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"parse_state.pos = star_pos\n", 0)
     append_data(runtime.current_chunk_buffer, b"break\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"star_last = append_named_action(star_last, None, _)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_named_action2(variables, None, _)\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
-    append_data(runtime.current_chunk_buffer, b"_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variable):
     pass
@@ -583,8 +620,7 @@ def rule_file(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    star_pre_first = Variable()
-    star_last = star_pre_first
+    variables = create_variables()
     star_start_pos = parse_state.pos
     while True:
         star_pos = parse_state.pos
@@ -592,8 +628,8 @@ def rule_file(parse_state):
         if _ == ERROR:
             parse_state.pos = star_pos
             break
-        star_last = append_named_action(star_last, None, _)
-    _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        append_named_action2(variables, None, _)
+    _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
     last_variable = append_named_action(last_variable, 'xs', _)
     if _ != ERROR:
         _ = rule_space(parse_state)
@@ -661,8 +697,7 @@ def rule_ors(parse_state):
         _ = rule_orcase(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            star_pre_first = Variable()
-            star_last = star_pre_first
+            variables = create_variables()
             star_start_pos = parse_state.pos
             while True:
                 star_pos = parse_state.pos
@@ -670,8 +705,8 @@ def rule_ors(parse_state):
                 if _ == ERROR:
                     parse_state.pos = star_pos
                     break
-                star_last = append_named_action(star_last, None, _)
-            _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                append_named_action2(variables, None, _)
+            _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
                 return Action(action_4, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
@@ -899,8 +934,7 @@ def rule_action(parse_state):
                 else:
                     _ = ERROR
                 if _ != ERROR:
-                    star_pre_first = Variable()
-                    star_last = star_pre_first
+                    variables = create_variables()
                     star_start_pos = parse_state.pos
                     while True:
                         star_pos = parse_state.pos
@@ -908,8 +942,8 @@ def rule_action(parse_state):
                         if _ == ERROR:
                             parse_state.pos = star_pos
                             break
-                        star_last = append_named_action(star_last, None, _)
-                    _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                        append_named_action2(variables, None, _)
+                    _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
                     last_variable = append_named_action(last_variable, 'xs', _)
                     if _ != ERROR:
                         _ = rule_space(parse_state)
@@ -956,8 +990,7 @@ def rule_actionexpr(parse_state):
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        star_pre_first = Variable()
-                        star_last = star_pre_first
+                        variables = create_variables()
                         star_start_pos = parse_state.pos
                         while True:
                             star_pos = parse_state.pos
@@ -965,8 +998,8 @@ def rule_actionexpr(parse_state):
                             if _ == ERROR:
                                 parse_state.pos = star_pos
                                 break
-                            star_last = append_named_action(star_last, None, _)
-                        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                            append_named_action2(variables, None, _)
+                        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
                         last_variable = append_named_action(last_variable, 'ys', _)
                         if _ != ERROR:
                             _ = rule_space(parse_state)
@@ -1093,8 +1126,7 @@ def rule_actionexpr(parse_state):
         else:
             _ = ERROR
         if _ != ERROR:
-            star_pre_first = Variable()
-            star_last = star_pre_first
+            variables = create_variables()
             star_start_pos = parse_state.pos
             while True:
                 star_pos = parse_state.pos
@@ -1102,8 +1134,8 @@ def rule_actionexpr(parse_state):
                 if _ == ERROR:
                     parse_state.pos = star_pos
                     break
-                star_last = append_named_action(star_last, None, _)
-            _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+                append_named_action2(variables, None, _)
+            _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
                 _ = rule_space(parse_state)
@@ -1358,8 +1390,7 @@ def rule_string(parse_state):
     else:
         _ = ERROR
     if _ != ERROR:
-        star_pre_first = Variable()
-        star_last = star_pre_first
+        variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1367,8 +1398,8 @@ def rule_string(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            star_last = append_named_action(star_last, None, _)
-        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action2(variables, None, _)
+        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             data = b'"'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
@@ -1389,8 +1420,7 @@ def rule_dotname(parse_state):
     _ = rule_name(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        star_pre_first = Variable()
-        star_last = star_pre_first
+        variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1398,8 +1428,8 @@ def rule_dotname(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            star_last = append_named_action(star_last, None, _)
-        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action2(variables, None, _)
+        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         last_variable = append_named_action(last_variable, 'xs', _)
         if _ != ERROR:
             return Action(action_33, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
@@ -1500,8 +1530,7 @@ def rule_charstring(parse_state):
     last_variable = pre_first_variable
     _ = rule_quote(parse_state)
     if _ != ERROR:
-        star_pre_first = Variable()
-        star_last = star_pre_first
+        variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1509,8 +1538,8 @@ def rule_charstring(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            star_last = append_named_action(star_last, None, _)
-        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action2(variables, None, _)
+        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             _ = rule_quote(parse_state)
             if _ != ERROR:
@@ -1576,8 +1605,7 @@ def rule_name(parse_state):
     last_variable = pre_first_variable
     _ = rule_char(parse_state)
     if _ != ERROR:
-        star_pre_first = Variable()
-        star_last = star_pre_first
+        variables = create_variables()
         star_start_pos = parse_state.pos
         while True:
             star_pos = parse_state.pos
@@ -1585,8 +1613,8 @@ def rule_name(parse_state):
             if _ == ERROR:
                 parse_state.pos = star_pos
                 break
-            star_last = append_named_action(star_last, None, _)
-        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+            append_named_action2(variables, None, _)
+        _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
@@ -2225,8 +2253,7 @@ def rule_space(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    star_pre_first = Variable()
-    star_last = star_pre_first
+    variables = create_variables()
     star_start_pos = parse_state.pos
     while True:
         star_pos = parse_state.pos
@@ -2234,8 +2261,8 @@ def rule_space(parse_state):
         if _ == ERROR:
             parse_state.pos = star_pos
             break
-        star_last = append_named_action(star_last, None, _)
-    _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
+        append_named_action2(variables, None, _)
+    _ = Action(None, variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
     if _ != ERROR:
         return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 3c2be24..dd8c2cf 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -43,12 +43,15 @@ file = rule*:xs space !. -> {
         "indentation_delta = None\n"
     <
     "\n"
+    "class Variables:\n" >
+        "pre_first = None\n"
+        "last = None\n"
+    <
+    "\n"
     "class Variable:\n" >
-        "def __init__(self):\n" >
-            "self.next = None\n"
-            "self.name = None\n"
-            "self.action = None\n"
-        <
+        "next = None\n"
+        "name = None\n"
+        "action = None\n"
     <
     "\n"
     "def run_action(action, runtime):\n" >
@@ -69,6 +72,13 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
+    "def create_variables():\n" >
+        "variables = Variables()\n"
+        "variables.pre_first = Variable()\n"
+        "variables.last = variables.pre_first\n"
+        "return variables\n"
+    <
+    "\n"
     "def create_chunk_buffer():\n" >
         "chunk_buffer = ChunkBuffer()\n"
         "chunk_buffer.pre_first = Chunk()\n"
@@ -86,6 +96,15 @@ file = rule*:xs space !. -> {
         "chunk_buffer.last = chunk\n"
     <
     "\n"
+    "def append_named_action2(variables, name, action):\n" >
+        "next_variable = Variable()\n"
+        "next_variable.next = None\n"
+        "next_variable.name = name\n"
+        "next_variable.action = action\n"
+        "variables.last.next = next_variable\n"
+        "variables.last = next_variable\n"
+    <
+    "\n"
     "def append_named_action(variable, name, action):\n" >
         "next_variable = Variable()\n"
         "next_variable.next = variable.next\n"
@@ -208,8 +227,7 @@ matchAssign =
 
 matchExprRepeat =
     | matchExprPrimitive:x '*' -> {
-        "star_pre_first = Variable()\n"
-        "star_last = star_pre_first\n"
+        "star_variables = create_variables()\n"
         "star_start_pos = parse_state.pos\n"
         "while True:\n" >
             "star_pos = parse_state.pos\n"
@@ -218,9 +236,9 @@ matchExprRepeat =
                 "parse_state.pos = star_pos\n"
                 "break\n"
             <
-            "star_last = append_named_action(star_last, None, _)\n"
+            "append_named_action2(star_variables, None, _)\n"
         <
-        "_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
+        "_ = Action(None, star_variables.pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
     }
     | matchExprPrimitive:x -> {
         x

commit bce7c1c4b0d6d0a00ac935fa89ae27522d7f15d2
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 20:42:26 2025 +0100

    More C, struct like structure of chunk buffer

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index d3ca9e0..94caae6 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -7,7 +7,7 @@ class ParseState:
 
 class Runtime:
     def __init__(self):
-        self.output_chunk_buffer = ChunkBuffer()
+        self.output_chunk_buffer = create_chunk_buffer()
         self.current_chunk_buffer = self.output_chunk_buffer
         self.action_chunk_buffer = None
         self.namedBuffers_chunk_buffer = None
@@ -25,16 +25,14 @@ class Action:
         self.len = end-start
 
 class ChunkBuffer:
-    def __init__(self):
-        self.pre_start = Chunk()
-        self.last = self.pre_start
+    pre_first = None
+    last = None
 
 class Chunk:
-    def __init__(self):
-        self.next = None
-        self.data = None
-        self.chunk_buffer = None
-        self.indentation_delta = None
+    next = None
+    data = None
+    chunk_buffer = None
+    indentation_delta = None
 
 class Variable:
     def __init__(self):
@@ -54,6 +52,12 @@ def run_action(action, runtime):
     else:
         action.function(runtime, action.variable)
 
+def create_chunk_buffer():
+    chunk_buffer = ChunkBuffer()
+    chunk_buffer.pre_first = Chunk()
+    chunk_buffer.last = chunk_buffer.pre_first
+    return chunk_buffer
+
 def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):
     chunk = Chunk()
     chunk.next = None
@@ -85,7 +89,7 @@ def inc(value, amount):
 
 def render_chunk_buffer(chunk_buffer, last_char=b'\n', indent=0):
     if chunk_buffer:
-        chunk = chunk_buffer.pre_start.next
+        chunk = chunk_buffer.pre_first.next
         while chunk:
             indent += chunk.indentation_delta
             for char in chunk.data:
@@ -120,11 +124,11 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"self.output_chunk_buffer = ChunkBuffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.output_chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
-    new_chunk_buffer = ChunkBuffer()
-    runtime.namedBuffers_chunk_buffer = new_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)
+    chunk_buffer = create_chunk_buffer()
+    runtime.namedBuffers_chunk_buffer = chunk_buffer
+    append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
     append_data(runtime.current_chunk_buffer, b"self.placeholders = []\n", 0)
     append_data(runtime.current_chunk_buffer, b"self.W = {}\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
@@ -145,22 +149,16 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class ChunkBuffer:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"self.pre_start = Chunk()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.last = self.pre_start\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"pre_first = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"last = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Chunk:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"self.next = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.data = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.chunk_buffer = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b"self.indentation_delta = None\n", 0)
-    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"data = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"indentation_delta = None\n", 0)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"class Variable:\n", 0)
@@ -197,6 +195,14 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def create_chunk_buffer():\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = ChunkBuffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer.pre_first = Chunk()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk_buffer.pre_first\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"chunk = Chunk()\n", 0)
@@ -244,7 +250,7 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"if chunk_buffer:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
-    append_data(runtime.current_chunk_buffer, b"chunk = chunk_buffer.pre_start.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk = chunk_buffer.pre_first.next\n", 0)
     append_data(runtime.current_chunk_buffer, b"while chunk:\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
     append_data(runtime.current_chunk_buffer, b"indent += chunk.indentation_delta\n", 0)
@@ -266,12 +272,12 @@ def action_2(runtime, variable):
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     append_data(runtime.current_chunk_buffer, b"ERROR = -1\n", 0)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
-    new_chunk_buffer = ChunkBuffer()
-    runtime.action_chunk_buffer = new_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)
-    new_chunk_buffer = ChunkBuffer()
-    runtime.placeholder_chunk_buffer = new_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)
+    chunk_buffer = create_chunk_buffer()
+    runtime.action_chunk_buffer = chunk_buffer
+    append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
+    chunk_buffer = create_chunk_buffer()
+    runtime.placeholder_chunk_buffer = chunk_buffer
+    append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)
     run_action(lookup_action(variable, 'xs'), runtime)
     append_data(runtime.current_chunk_buffer, b"if __name__ == '__main__':\n", 0)
     append_data(runtime.current_chunk_buffer, b'', 1)
@@ -455,11 +461,11 @@ def action_21(runtime, variable):
 
 def action_22(runtime, variable):
     pass
-    append_data(runtime.current_chunk_buffer, b"new_chunk_buffer = ChunkBuffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
     append_data(runtime.current_chunk_buffer, b"runtime.", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    append_data(runtime.current_chunk_buffer, b"_chunk_buffer = new_chunk_buffer\n", 0)
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_chunk_buffer = chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
 def action_23(runtime, variable):
     pass
@@ -488,11 +494,11 @@ def action_25(runtime, variable):
     append_data(runtime.current_chunk_buffer, b'', -1)
     append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    append_data(runtime.current_chunk_buffer, b"new_chunk_buffer = ChunkBuffer()\n", 0)
-    append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((new_chunk_buffer, Action(placeholder_", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = create_chunk_buffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((chunk_buffer, Action(placeholder_", 0)
     append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
     append_data(runtime.current_chunk_buffer, b", variable, '', 0, 0)))\n", 0)
-    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n", 0)
 
 def action_26(runtime, variable):
     pass
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 3e23f1a..3c2be24 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -12,7 +12,7 @@ file = rule*:xs space !. -> {
     "\n"
     "class Runtime:\n" >
         "def __init__(self):\n" >
-            "self.output_chunk_buffer = ChunkBuffer()\n"
+            "self.output_chunk_buffer = create_chunk_buffer()\n"
             "self.current_chunk_buffer = self.output_chunk_buffer\n"
             <namedBuffers
             "self.placeholders = []\n"
@@ -32,19 +32,15 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "class ChunkBuffer:\n" >
-        "def __init__(self):\n" >
-            "self.pre_start = Chunk()\n"
-            "self.last = self.pre_start\n"
-        <
+        "pre_first = None\n"
+        "last = None\n"
     <
     "\n"
     "class Chunk:\n" >
-        "def __init__(self):\n" >
-            "self.next = None\n"
-            "self.data = None\n"
-            "self.chunk_buffer = None\n"
-            "self.indentation_delta = None\n"
-        <
+        "next = None\n"
+        "data = None\n"
+        "chunk_buffer = None\n"
+        "indentation_delta = None\n"
     <
     "\n"
     "class Variable:\n" >
@@ -73,6 +69,13 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
+    "def create_chunk_buffer():\n" >
+        "chunk_buffer = ChunkBuffer()\n"
+        "chunk_buffer.pre_first = Chunk()\n"
+        "chunk_buffer.last = chunk_buffer.pre_first\n"
+        "return chunk_buffer\n"
+    <
+    "\n"
     "def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n" >
         "chunk = Chunk()\n"
         "chunk.next = None\n"
@@ -111,7 +114,7 @@ file = rule*:xs space !. -> {
     "\n"
     "def render_chunk_buffer(chunk_buffer, last_char=b'\\n', indent=0):\n" >
         "if chunk_buffer:\n" >
-            "chunk = chunk_buffer.pre_start.next\n"
+            "chunk = chunk_buffer.pre_first.next\n"
             "while chunk:\n" >
                 "indent += chunk.indentation_delta\n"
                 "for char in chunk.data:\n" >
@@ -278,9 +281,9 @@ actionexpr =
         }
     }
     | space '<' name:x -> {
-        "new_chunk_buffer = ChunkBuffer()\n"
-        "runtime." x "_chunk_buffer = new_chunk_buffer\n"
-        "append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n"
+        "chunk_buffer = create_chunk_buffer()\n"
+        "runtime." x "_chunk_buffer = chunk_buffer\n"
+        "append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n"
     }
     | space expr:x -> {
         "append_data(runtime.current_chunk_buffer, str(" x ").encode('ascii'), 0)\n"
@@ -297,9 +300,9 @@ actionexpr =
             <
             "\n"
         }
-        "new_chunk_buffer = ChunkBuffer()\n"
-        "runtime.placeholders.append((new_chunk_buffer, Action(placeholder_" W[1] ", variable, '', 0, 0)))\n"
-        "append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n"
+        "chunk_buffer = create_chunk_buffer()\n"
+        "runtime.placeholders.append((chunk_buffer, Action(placeholder_" W[1] ", variable, '', 0, 0)))\n"
+        "append_data(runtime.current_chunk_buffer, b'', 0, chunk_buffer)\n"
     }
     | space string:x -> {
         "append_data(runtime.current_chunk_buffer, b" x ", 0)\n"

commit ead772d535ed0abbdb99e5da7c1dd72b23f2f764
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 20:35:25 2025 +0100

    Cleaner way of appending to a chunk buffer

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 101a8a7..d3ca9e0 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -45,7 +45,7 @@ class Variable:
 def run_action(action, runtime):
     if action.function is None:
         if action.variable is None:
-            runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)
+            append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)
         else:
             variable = action.variable
             while variable:
@@ -54,14 +54,14 @@ def run_action(action, runtime):
     else:
         action.function(runtime, action.variable)
 
-def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):
-    next_chunk = Chunk()
-    next_chunk.next = chunk.next
-    next_chunk.data = data
-    next_chunk.chunk_buffer = sub_chunk_buffer
-    next_chunk.indentation_delta = indentation_delta
-    chunk.next = next_chunk
-    return next_chunk
+def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):
+    chunk = Chunk()
+    chunk.next = None
+    chunk.data = data
+    chunk.chunk_buffer = sub_chunk_buffer
+    chunk.indentation_delta = indentation_delta
+    chunk_buffer.last.next = chunk
+    chunk_buffer.last = chunk
 
 def append_named_action(variable, name, action):
     next_variable = Variable()
@@ -105,203 +105,203 @@ def action_1(runtime, variable):
 
 def action_2(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"import sys\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class ParseState:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self, input_buffer):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.input_buffer = input_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.pos = 0\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Runtime:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.output_chunk_buffer = ChunkBuffer()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"import sys\n", 0)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class ParseState:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"def __init__(self, input_buffer):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"self.input_buffer = input_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.pos = 0\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Runtime:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"self.output_chunk_buffer = ChunkBuffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
     new_chunk_buffer = ChunkBuffer()
     runtime.namedBuffers_chunk_buffer = new_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.placeholders = []\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.W = {}\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Action:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self, function, variable, input_buffer, start, end):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.function = function\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.variable = variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.input_buffer = input_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.start = start\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.end = end\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.len = end-start\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class ChunkBuffer:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.pre_start = Chunk()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.last = self.pre_start\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Chunk:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.next = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.data = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.chunk_buffer = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.indentation_delta = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Variable:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.next = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.name = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.action = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def run_action(action, runtime):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if action.function is None:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if action.variable is None:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = action.variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while variable:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(variable.action, runtime)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = variable.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"action.function(runtime, action.variable)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk = Chunk()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.next = chunk.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.data = data\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.chunk_buffer = sub_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.indentation_delta = indentation_delta\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk.next = next_chunk\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return next_chunk\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def append_named_action(variable, name, action):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable = Variable()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable.next = variable.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable.name = name\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable.action = action\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable.next = next_variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return next_variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def lookup_action(variable, name_to_look_for):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while variable:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if variable.name == name_to_look_for:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return variable.action\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = variable.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def inc(value, amount):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return value + amount\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def render_chunk_buffer(chunk_buffer, last_char=b'\\n', indent=0):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if chunk_buffer:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk = chunk_buffer.pre_start.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while chunk:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"indent += chunk.indentation_delta\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"for char in chunk.data:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if last_char == b'\\n':\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"sys.stdout.buffer.write(b'    '*indent)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_char = char.to_bytes()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"sys.stdout.buffer.write(last_char)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk = chunk.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return last_char, indent\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"ERROR = -1\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)
+    append_data(runtime.current_chunk_buffer, b"self.placeholders = []\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.W = {}\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Action:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"def __init__(self, function, variable, input_buffer, start, end):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"self.function = function\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.variable = variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.input_buffer = input_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.start = start\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.end = end\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.len = end-start\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class ChunkBuffer:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"self.pre_start = Chunk()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.last = self.pre_start\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Chunk:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"self.next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.data = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.chunk_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.indentation_delta = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"class Variable:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"def __init__(self):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"self.next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.name = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"self.action = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def run_action(action, runtime):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"if action.function is None:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"if action.variable is None:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"variable = action.variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"while variable:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"run_action(variable.action, runtime)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variable = variable.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"action.function(runtime, action.variable)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"chunk = Chunk()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk.next = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk.data = data\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk.chunk_buffer = sub_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk.indentation_delta = indentation_delta\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last.next = chunk\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer.last = chunk\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def append_named_action(variable, name, action):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"next_variable = Variable()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.next = variable.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.name = name\n", 0)
+    append_data(runtime.current_chunk_buffer, b"next_variable.action = action\n", 0)
+    append_data(runtime.current_chunk_buffer, b"variable.next = next_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return next_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def lookup_action(variable, name_to_look_for):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"variable = variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"while variable:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"if variable.name == name_to_look_for:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"return variable.action\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"variable = variable.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def inc(value, amount):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"return value + amount\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def render_chunk_buffer(chunk_buffer, last_char=b'\\n', indent=0):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"if chunk_buffer:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"chunk = chunk_buffer.pre_start.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b"while chunk:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"indent += chunk.indentation_delta\n", 0)
+    append_data(runtime.current_chunk_buffer, b"for char in chunk.data:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"if last_char == b'\\n':\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"sys.stdout.buffer.write(b'    '*indent)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"last_char = char.to_bytes()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"sys.stdout.buffer.write(last_char)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk = chunk.next\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"return last_char, indent\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"ERROR = -1\n", 0)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     new_chunk_buffer = ChunkBuffer()
     runtime.action_chunk_buffer = new_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)
+    append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)
     new_chunk_buffer = ChunkBuffer()
     runtime.placeholder_chunk_buffer = new_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)
+    append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if __name__ == '__main__':\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state = ParseState(sys.stdin.buffer.read())\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime = Runtime()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(rule_main(parse_state), runtime)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"for chunk_buffer, action in runtime.placeholders:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(action, runtime)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"if __name__ == '__main__':\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"parse_state = ParseState(sys.stdin.buffer.read())\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime = Runtime()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"run_action(rule_main(parse_state), runtime)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"for chunk_buffer, action in runtime.placeholders:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"run_action(action, runtime)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
 
 def action_3(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def rule_", 0)
+    append_data(runtime.current_chunk_buffer, b"def rule_", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(parse_state):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"(parse_state):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
 
 def action_4(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"or_backtrack_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"or_backtrack_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return ERROR\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return ERROR\n", 0)
 
 def action_5(runtime, variable):
     pass
@@ -312,19 +312,19 @@ def action_6(runtime, variable):
 
 def action_7(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos = or_backtrack_pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"action_start_pos = parse_state.pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"pre_first_variable = Variable()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_variable = pre_first_variable\n", 0)
+    append_data(runtime.current_chunk_buffer, b"parse_state.pos = or_backtrack_pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"action_start_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"pre_first_variable = Variable()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"last_variable = pre_first_variable\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
 
 def action_8(runtime, variable):
     pass
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if _ != ERROR:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"if _ != ERROR:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    append_data(runtime.current_chunk_buffer, b'', -1)
 
 def action_9(runtime, variable):
     pass
@@ -332,17 +332,17 @@ def action_9(runtime, variable):
 
 def action_10(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"nlookahead_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"nlookahead_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if _ == ERROR:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = lambda: None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = ERROR\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos = nlookahead_pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"if _ == ERROR:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"_ = lambda: None\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"parse_state.pos = nlookahead_pos\n", 0)
 
 def action_11(runtime, variable):
     pass
@@ -351,30 +351,30 @@ def action_11(runtime, variable):
 
 def action_12(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_variable = append_named_action(last_variable, '", 0)
+    append_data(runtime.current_chunk_buffer, b"last_variable = append_named_action(last_variable, '", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"', _)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"', _)\n", 0)
 
 def action_13(runtime, variable):
     pass
 
 def action_14(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_pre_first = Variable()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_last = star_pre_first\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_start_pos = parse_state.pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while True:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"star_pre_first = Variable()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"star_last = star_pre_first\n", 0)
+    append_data(runtime.current_chunk_buffer, b"star_start_pos = parse_state.pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"while True:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"star_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if _ == ERROR:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos = star_pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"break\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_last = append_named_action(star_last, None, _)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"if _ == ERROR:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"parse_state.pos = star_pos\n", 0)
+    append_data(runtime.current_chunk_buffer, b"break\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"star_last = append_named_action(star_last, None, _)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variable):
     pass
@@ -382,36 +382,36 @@ def action_15(runtime, variable):
 
 def action_16(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = rule_", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = rule_", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(parse_state)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"(parse_state)\n", 0)
 
 def action_17(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos += 1\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = ERROR\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"parse_state.pos += 1\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
 
 def action_18(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"data = b", 0)
+    append_data(runtime.current_chunk_buffer, b"data = b", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos += len(data)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = ERROR\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"parse_state.pos += len(data)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"else:\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"_ = ERROR\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
 
 def action_19(runtime, variable):
     pass
@@ -419,59 +419,59 @@ def action_19(runtime, variable):
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.action_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def action_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)).encode('ascii'), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime, variable):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"pass\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def action_", 0)
+    append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime, variable):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"pass\n", 0)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return Action(action_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)).encode('ascii'), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return Action(action_", 0)
+    append_data(runtime.current_chunk_buffer, str(runtime.W.get(0, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, b", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_21(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk_buffer = runtime.", 0)
+    append_data(runtime.current_chunk_buffer, b"last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"chunk_buffer = runtime.", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
     run_action(lookup_action(variable, 'ys'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer = last_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.current_chunk_buffer = last_chunk_buffer\n", 0)
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.namedBuffers_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.", 0)
+    append_data(runtime.current_chunk_buffer, b"self.", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_chunk_buffer = None\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_chunk_buffer = None\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
 
 def action_22(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"new_chunk_buffer = ChunkBuffer()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.", 0)
+    append_data(runtime.current_chunk_buffer, b"new_chunk_buffer = ChunkBuffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_chunk_buffer = new_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"_chunk_buffer = new_chunk_buffer\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n", 0)
 
 def action_23(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, str(", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b").encode('ascii'), 0)\n", 0)
+    append_data(runtime.current_chunk_buffer, b").encode('ascii'), 0)\n", 0)
 
 def action_24(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(lookup_action(variable, '", 0)
+    append_data(runtime.current_chunk_buffer, b"run_action(lookup_action(variable, '", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"'), runtime)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"'), runtime)\n", 0)
 
 def action_25(runtime, variable):
     pass
@@ -479,44 +479,44 @@ def action_25(runtime, variable):
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.placeholder_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def placeholder_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)).encode('ascii'), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime, variable):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"pass\n", 0)
+    append_data(runtime.current_chunk_buffer, b"def placeholder_", 0)
+    append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime, variable):\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', 1)
+    append_data(runtime.current_chunk_buffer, b"pass\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    append_data(runtime.current_chunk_buffer, b'', -1)
+    append_data(runtime.current_chunk_buffer, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"new_chunk_buffer = ChunkBuffer()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.placeholders.append((new_chunk_buffer, Action(placeholder_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)).encode('ascii'), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", variable, '', 0, 0)))\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"new_chunk_buffer = ChunkBuffer()\n", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.placeholders.append((new_chunk_buffer, Action(placeholder_", 0)
+    append_data(runtime.current_chunk_buffer, str(runtime.W.get(1, 0)).encode('ascii'), 0)
+    append_data(runtime.current_chunk_buffer, b", variable, '', 0, 0)))\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n", 0)
 
 def action_26(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)\n", 0)
+    append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
 
 def action_27(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.W[", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.W[", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"] = ", 0)
+    append_data(runtime.current_chunk_buffer, b"] = ", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime.W.get(", 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime.W.get(", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0), ", 0)
+    append_data(runtime.current_chunk_buffer, b", 0), ", 0)
     run_action(lookup_action(variable, 'z'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b")\n", 0)
+    append_data(runtime.current_chunk_buffer, b")\n", 0)
 
 def action_28(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', 1)\n", 0)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)\n", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b'', -1)\n", 0)
 
 def action_29(runtime, variable):
     pass
@@ -524,31 +524,31 @@ def action_29(runtime, variable):
 
 def action_30(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)
+    append_data(runtime.current_chunk_buffer, b"append_data(runtime.current_chunk_buffer, b", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"*", 0)
+    append_data(runtime.current_chunk_buffer, b"*", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)\n", 0)
+    append_data(runtime.current_chunk_buffer, b", 0)\n", 0)
 
 def action_31(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.W.get(", 0)
+    append_data(runtime.current_chunk_buffer, b"runtime.W.get(", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)", 0)
+    append_data(runtime.current_chunk_buffer, b", 0)", 0)
 
 def action_32(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime.W.get(", 0)
+    append_data(runtime.current_chunk_buffer, b"(runtime.W.get(", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)-", 0)
+    append_data(runtime.current_chunk_buffer, b", 0)-", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b")", 0)
+    append_data(runtime.current_chunk_buffer, b")", 0)
 
 def action_33(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"lookup_action(variable, '", 0)
+    append_data(runtime.current_chunk_buffer, b"lookup_action(variable, '", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"')", 0)
+    append_data(runtime.current_chunk_buffer, b"')", 0)
     run_action(lookup_action(variable, 'xs'), runtime)
 
 def action_34(runtime, variable):
@@ -557,7 +557,7 @@ def action_34(runtime, variable):
 
 def action_35(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"'", 0)
+    append_data(runtime.current_chunk_buffer, b"'", 0)
 
 def rule_main(parse_state):
     or_backtrack_pos = parse_state.pos
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index d055dab..3e23f1a 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -58,7 +58,7 @@ file = rule*:xs space !. -> {
     "def run_action(action, runtime):\n" >
         "if action.function is None:\n" >
             "if action.variable is None:\n" >
-                "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n"
+                "append_data(runtime.current_chunk_buffer, action.input_buffer[action.start:action.end], 0)\n"
             <
             "else:\n" >
                 "variable = action.variable\n"
@@ -73,14 +73,14 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
-    "def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n" >
-        "next_chunk = Chunk()\n"
-        "next_chunk.next = chunk.next\n"
-        "next_chunk.data = data\n"
-        "next_chunk.chunk_buffer = sub_chunk_buffer\n"
-        "next_chunk.indentation_delta = indentation_delta\n"
-        "chunk.next = next_chunk\n"
-        "return next_chunk\n"
+    "def append_data(chunk_buffer, data, indentation_delta, sub_chunk_buffer=None):\n" >
+        "chunk = Chunk()\n"
+        "chunk.next = None\n"
+        "chunk.data = data\n"
+        "chunk.chunk_buffer = sub_chunk_buffer\n"
+        "chunk.indentation_delta = indentation_delta\n"
+        "chunk_buffer.last.next = chunk\n"
+        "chunk_buffer.last = chunk\n"
     <
     "\n"
     "def append_named_action(variable, name, action):\n" >
@@ -280,10 +280,10 @@ actionexpr =
     | space '<' name:x -> {
         "new_chunk_buffer = ChunkBuffer()\n"
         "runtime." x "_chunk_buffer = new_chunk_buffer\n"
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n"
+        "append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n"
     }
     | space expr:x -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(" x ").encode('ascii'), 0)\n"
+        "append_data(runtime.current_chunk_buffer, str(" x ").encode('ascii'), 0)\n"
     }
     | space name:x -> {
         "run_action(lookup_action(variable, '" x "'), runtime)\n"
@@ -299,18 +299,18 @@ actionexpr =
         }
         "new_chunk_buffer = ChunkBuffer()\n"
         "runtime.placeholders.append((new_chunk_buffer, Action(placeholder_" W[1] ", variable, '', 0, 0)))\n"
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n"
+        "append_data(runtime.current_chunk_buffer, b'', 0, new_chunk_buffer)\n"
     }
     | space string:x -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b" x ", 0)\n"
+        "append_data(runtime.current_chunk_buffer, b" x ", 0)\n"
     }
     | space '#' name:x '(' wvar:y ' ' actionPrimitiveExpression:z ')' -> {
         "runtime.W[" y "] = " x "(runtime.W.get(" y ", 0), " z ")\n"
     }
     | space '>' actionexpr*:xs space '<' -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)\n"
+        "append_data(runtime.current_chunk_buffer, b'', 1)\n"
         xs
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)\n"
+        "append_data(runtime.current_chunk_buffer, b'', -1)\n"
     }
     ;
 
@@ -334,7 +334,7 @@ digit =
 
 placeholder
     = '{' space string:x '*' expr:y space '}' -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b" x "*" y ", 0)\n"
+        "append_data(runtime.current_chunk_buffer, b" x "*" y ", 0)\n"
     }
     ;
 

commit c352cdfbafe1004210eae77bf6f934edb33feaac
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Thu Oct 30 20:20:19 2025 +0100

    Use bytes data type in Python

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 857a421..101a8a7 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -83,16 +83,16 @@ def lookup_action(variable, name_to_look_for):
 def inc(value, amount):
     return value + amount
 
-def render_chunk_buffer(chunk_buffer, last_char='\n', indent=0):
+def render_chunk_buffer(chunk_buffer, last_char=b'\n', indent=0):
     if chunk_buffer:
         chunk = chunk_buffer.pre_start.next
         while chunk:
             indent += chunk.indentation_delta
             for char in chunk.data:
-                if last_char == '\n':
-                    sys.stdout.write('    '*indent)
-                last_char = char
-                sys.stdout.write(last_char)
+                if last_char == b'\n':
+                    sys.stdout.buffer.write(b'    '*indent)
+                last_char = char.to_bytes()
+                sys.stdout.buffer.write(last_char)
             last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)
             chunk = chunk.next
     return last_char, indent
@@ -105,203 +105,203 @@ def action_1(runtime, variable):
 
 def action_2(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "import sys\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class ParseState:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self, input_buffer):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.pos = 0\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Runtime:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.output_chunk_buffer = ChunkBuffer()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"import sys\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class ParseState:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self, input_buffer):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.input_buffer = input_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.pos = 0\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Runtime:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.output_chunk_buffer = ChunkBuffer()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
     new_chunk_buffer = ChunkBuffer()
     runtime.namedBuffers_chunk_buffer = new_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.placeholders = []\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.W = {}\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Action:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self, function, variable, input_buffer, start, end):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.function = function\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.variable = variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.start = start\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.end = end\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.len = end-start\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class ChunkBuffer:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.pre_start = Chunk()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.last = self.pre_start\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Chunk:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.next = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.data = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.chunk_buffer = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.indentation_delta = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Variable:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.next = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.name = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.action = None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def run_action(action, runtime):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if action.function is None:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if action.variable is None:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = action.variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while variable:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(variable.action, runtime)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = variable.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "action.function(runtime, action.variable)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk = Chunk()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.next = chunk.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.data = data\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.chunk_buffer = sub_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.indentation_delta = indentation_delta\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk.next = next_chunk\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return next_chunk\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def append_named_action(variable, name, action):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable = Variable()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable.next = variable.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable.name = name\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable.action = action\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable.next = next_variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return next_variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def lookup_action(variable, name_to_look_for):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = variable\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while variable:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if variable.name == name_to_look_for:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return variable.action\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = variable.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def inc(value, amount):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return value + amount\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def render_chunk_buffer(chunk_buffer, last_char='\\n', indent=0):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if chunk_buffer:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk = chunk_buffer.pre_start.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while chunk:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "indent += chunk.indentation_delta\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "for char in chunk.data:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if last_char == '\\n':\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "sys.stdout.write('    '*indent)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_char = char\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "sys.stdout.write(last_char)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk = chunk.next\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return last_char, indent\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "ERROR = -1\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.placeholders = []\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.W = {}\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Action:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self, function, variable, input_buffer, start, end):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.function = function\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.variable = variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.input_buffer = input_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.start = start\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.end = end\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.len = end-start\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class ChunkBuffer:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.pre_start = Chunk()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.last = self.pre_start\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Chunk:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.next = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.data = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.chunk_buffer = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.indentation_delta = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"class Variable:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.next = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.name = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.action = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def run_action(action, runtime):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if action.function is None:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if action.variable is None:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = action.variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while variable:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(variable.action, runtime)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = variable.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"action.function(runtime, action.variable)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk = Chunk()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.next = chunk.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.data = data\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.chunk_buffer = sub_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_chunk.indentation_delta = indentation_delta\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk.next = next_chunk\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return next_chunk\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def append_named_action(variable, name, action):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable = Variable()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable.next = variable.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable.name = name\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"next_variable.action = action\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable.next = next_variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return next_variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def lookup_action(variable, name_to_look_for):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while variable:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if variable.name == name_to_look_for:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return variable.action\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"variable = variable.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def inc(value, amount):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return value + amount\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def render_chunk_buffer(chunk_buffer, last_char=b'\\n', indent=0):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if chunk_buffer:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk = chunk_buffer.pre_start.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while chunk:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"indent += chunk.indentation_delta\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"for char in chunk.data:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if last_char == b'\\n':\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"sys.stdout.buffer.write(b'    '*indent)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_char = char.to_bytes()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"sys.stdout.buffer.write(last_char)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk = chunk.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return last_char, indent\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"ERROR = -1\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
     new_chunk_buffer = ChunkBuffer()
     runtime.action_chunk_buffer = new_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)
     new_chunk_buffer = ChunkBuffer()
     runtime.placeholder_chunk_buffer = new_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if __name__ == '__main__':\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state = ParseState(sys.stdin.read())\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime = Runtime()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(rule_main(parse_state), runtime)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "for chunk_buffer, action in runtime.placeholders:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer = chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(action, runtime)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if __name__ == '__main__':\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state = ParseState(sys.stdin.buffer.read())\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime = Runtime()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(rule_main(parse_state), runtime)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"for chunk_buffer, action in runtime.placeholders:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(action, runtime)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
 
 def action_3(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def rule_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def rule_", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(parse_state):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(parse_state):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
 
 def action_4(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "or_backtrack_pos = parse_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"or_backtrack_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return ERROR\n", 0)
 
 def action_5(runtime, variable):
     pass
@@ -312,19 +312,19 @@ def action_6(runtime, variable):
 
 def action_7(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos = or_backtrack_pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "action_start_pos = parse_state.pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "pre_first_variable = Variable()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_variable = pre_first_variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos = or_backtrack_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"action_start_pos = parse_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"pre_first_variable = Variable()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_variable = pre_first_variable\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
 
 def action_8(runtime, variable):
     pass
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ != ERROR:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if _ != ERROR:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
 
 def action_9(runtime, variable):
     pass
@@ -332,17 +332,17 @@ def action_9(runtime, variable):
 
 def action_10(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "nlookahead_pos = parse_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"nlookahead_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = lambda: None\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = ERROR\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos = nlookahead_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if _ == ERROR:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = lambda: None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos = nlookahead_pos\n", 0)
 
 def action_11(runtime, variable):
     pass
@@ -351,30 +351,30 @@ def action_11(runtime, variable):
 
 def action_12(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_variable = append_named_action(last_variable, '", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_variable = append_named_action(last_variable, '", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "', _)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"', _)\n", 0)
 
 def action_13(runtime, variable):
     pass
 
 def action_14(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_pre_first = Variable()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_last = star_pre_first\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_start_pos = parse_state.pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while True:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_pos = parse_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_pre_first = Variable()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_last = star_pre_first\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_start_pos = parse_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"while True:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos = star_pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "break\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_last = append_named_action(star_last, None, _)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if _ == ERROR:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos = star_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"break\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"star_last = append_named_action(star_last, None, _)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variable):
     pass
@@ -382,36 +382,36 @@ def action_15(runtime, variable):
 
 def action_16(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = rule_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = rule_", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(parse_state)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(parse_state)\n", 0)
 
 def action_17(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if parse_state.pos != len(parse_state.input_buffer):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos += 1\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = ERROR\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if parse_state.pos != len(parse_state.input_buffer):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos += 1\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
 
 def action_18(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "data = ", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"data = b", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos += len(data)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = ERROR\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"parse_state.pos += len(data)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_ = ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
 
 def action_19(runtime, variable):
     pass
@@ -419,59 +419,59 @@ def action_19(runtime, variable):
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.action_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def action_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime, variable):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "pass\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def action_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)).encode('ascii'), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime, variable):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"pass\n", 0)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(action_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return Action(action_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)).encode('ascii'), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_21(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk_buffer = runtime.", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"chunk_buffer = runtime.", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer = chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer = chunk_buffer\n", 0)
     run_action(lookup_action(variable, 'ys'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer = last_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer = last_chunk_buffer\n", 0)
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.namedBuffers_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"self.", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_chunk_buffer = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_chunk_buffer = None\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
 
 def action_22(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"new_chunk_buffer = ChunkBuffer()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_chunk_buffer = new_chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"_chunk_buffer = new_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n", 0)
 
 def action_23(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "), 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b").encode('ascii'), 0)\n", 0)
 
 def action_24(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(lookup_action(variable, '", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"run_action(lookup_action(variable, '", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "'), runtime)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"'), runtime)\n", 0)
 
 def action_25(runtime, variable):
     pass
@@ -479,44 +479,44 @@ def action_25(runtime, variable):
     last_chunk_buffer = runtime.current_chunk_buffer
     chunk_buffer = runtime.placeholder_chunk_buffer
     runtime.current_chunk_buffer = chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def placeholder_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime, variable):\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "pass\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"def placeholder_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)).encode('ascii'), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime, variable):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"pass\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.placeholders.append((new_chunk_buffer, Action(placeholder_", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", variable, '', 0, 0)))\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"new_chunk_buffer = ChunkBuffer()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.placeholders.append((new_chunk_buffer, Action(placeholder_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)).encode('ascii'), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", variable, '', 0, 0)))\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n", 0)
 
 def action_26(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)\n", 0)
 
 def action_27(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.W[", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.W[", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "] = ", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"] = ", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime.W.get(", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime.W.get(", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0), ", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0), ", 0)
     run_action(lookup_action(variable, 'z'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ")\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b")\n", 0)
 
 def action_28(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)\n", 0)
     run_action(lookup_action(variable, 'xs'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)\n", 0)
 
 def action_29(runtime, variable):
     pass
@@ -524,31 +524,31 @@ def action_29(runtime, variable):
 
 def action_30(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "*", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"*", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)\n", 0)
 
 def action_31(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.W.get(", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"runtime.W.get(", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)", 0)
 
 def action_32(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime.W.get(", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"(runtime.W.get(", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)-", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b", 0)-", 0)
     run_action(lookup_action(variable, 'y'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ")", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b")", 0)
 
 def action_33(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "lookup_action(variable, '", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"lookup_action(variable, '", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "')", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"')", 0)
     run_action(lookup_action(variable, 'xs'), runtime)
 
 def action_34(runtime, variable):
@@ -557,7 +557,7 @@ def action_34(runtime, variable):
 
 def action_35(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "'", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b"'", 0)
 
 def rule_main(parse_state):
     or_backtrack_pos = parse_state.pos
@@ -620,7 +620,7 @@ def rule_rule(parse_state):
         if _ != ERROR:
             _ = rule_space(parse_state)
             if _ != ERROR:
-                data = '='
+                data = b'='
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
                     _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -634,7 +634,7 @@ def rule_rule(parse_state):
                         if _ != ERROR:
                             _ = rule_space(parse_state)
                             if _ != ERROR:
-                                data = ';'
+                                data = b';'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
                                     _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -709,7 +709,7 @@ def rule_orbar(parse_state):
     last_variable = pre_first_variable
     _ = rule_space(parse_state)
     if _ != ERROR:
-        data = '|'
+        data = b'|'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -762,7 +762,7 @@ def rule_matchExpr(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '!'
+    data = b'!'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -792,7 +792,7 @@ def rule_matchAssign(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = ':'
+    data = b':'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -819,7 +819,7 @@ def rule_matchExprRepeat(parse_state):
     _ = rule_matchExprPrimitive(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        data = '*'
+        data = b'*'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -851,7 +851,7 @@ def rule_matchExprPrimitive(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '.'
+    data = b'.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -877,7 +877,7 @@ def rule_action(parse_state):
     last_variable = pre_first_variable
     _ = rule_space(parse_state)
     if _ != ERROR:
-        data = '->'
+        data = b'->'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -886,7 +886,7 @@ def rule_action(parse_state):
         if _ != ERROR:
             _ = rule_space(parse_state)
             if _ != ERROR:
-                data = '{'
+                data = b'{'
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
                     _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -908,7 +908,7 @@ def rule_action(parse_state):
                     if _ != ERROR:
                         _ = rule_space(parse_state)
                         if _ != ERROR:
-                            data = '}'
+                            data = b'}'
                             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                 parse_state.pos += len(data)
                                 _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -931,7 +931,7 @@ def rule_actionexpr(parse_state):
     last_variable = pre_first_variable
     _ = rule_space(parse_state)
     if _ != ERROR:
-        data = '>'
+        data = b'>'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -943,7 +943,7 @@ def rule_actionexpr(parse_state):
             if _ != ERROR:
                 _ = rule_space(parse_state)
                 if _ != ERROR:
-                    data = '{'
+                    data = b'{'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
                         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -965,7 +965,7 @@ def rule_actionexpr(parse_state):
                         if _ != ERROR:
                             _ = rule_space(parse_state)
                             if _ != ERROR:
-                                data = '}'
+                                data = b'}'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
                                     _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -979,7 +979,7 @@ def rule_actionexpr(parse_state):
     last_variable = pre_first_variable
     _ = rule_space(parse_state)
     if _ != ERROR:
-        data = '<'
+        data = b'<'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1036,7 +1036,7 @@ def rule_actionexpr(parse_state):
     last_variable = pre_first_variable
     _ = rule_space(parse_state)
     if _ != ERROR:
-        data = '#'
+        data = b'#'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1046,7 +1046,7 @@ def rule_actionexpr(parse_state):
             _ = rule_name(parse_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
-                data = '('
+                data = b'('
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
                     _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1056,7 +1056,7 @@ def rule_actionexpr(parse_state):
                     _ = rule_wvar(parse_state)
                     last_variable = append_named_action(last_variable, 'y', _)
                     if _ != ERROR:
-                        data = ' '
+                        data = b' '
                         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                             parse_state.pos += len(data)
                             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1066,7 +1066,7 @@ def rule_actionexpr(parse_state):
                             _ = rule_actionPrimitiveExpression(parse_state)
                             last_variable = append_named_action(last_variable, 'z', _)
                             if _ != ERROR:
-                                data = ')'
+                                data = b')'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
                                     _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1080,7 +1080,7 @@ def rule_actionexpr(parse_state):
     last_variable = pre_first_variable
     _ = rule_space(parse_state)
     if _ != ERROR:
-        data = '>'
+        data = b'>'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
             _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1102,7 +1102,7 @@ def rule_actionexpr(parse_state):
             if _ != ERROR:
                 _ = rule_space(parse_state)
                 if _ != ERROR:
-                    data = '<'
+                    data = b'<'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
                         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1137,7 +1137,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '0'
+    data = b'0'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1149,7 +1149,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '1'
+    data = b'1'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1161,7 +1161,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '2'
+    data = b'2'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1173,7 +1173,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '3'
+    data = b'3'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1185,7 +1185,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '4'
+    data = b'4'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1197,7 +1197,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '5'
+    data = b'5'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1209,7 +1209,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '6'
+    data = b'6'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1221,7 +1221,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '7'
+    data = b'7'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1233,7 +1233,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '8'
+    data = b'8'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1245,7 +1245,7 @@ def rule_digit(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '9'
+    data = b'9'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1261,7 +1261,7 @@ def rule_placeholder(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '{'
+    data = b'{'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1273,7 +1273,7 @@ def rule_placeholder(parse_state):
             _ = rule_string(parse_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
-                data = '*'
+                data = b'*'
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
                     _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1285,7 +1285,7 @@ def rule_placeholder(parse_state):
                     if _ != ERROR:
                         _ = rule_space(parse_state)
                         if _ != ERROR:
-                            data = '}'
+                            data = b'}'
                             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                 parse_state.pos += len(data)
                                 _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1309,7 +1309,7 @@ def rule_expr(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '('
+    data = b'('
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1319,7 +1319,7 @@ def rule_expr(parse_state):
         _ = rule_wvar(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            data = '-'
+            data = b'-'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
                 _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1329,7 +1329,7 @@ def rule_expr(parse_state):
                 _ = rule_dotname(parse_state)
                 last_variable = append_named_action(last_variable, 'y', _)
                 if _ != ERROR:
-                    data = ')'
+                    data = b')'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
                         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1345,7 +1345,7 @@ def rule_string(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '"'
+    data = b'"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1364,7 +1364,7 @@ def rule_string(parse_state):
             star_last = append_named_action(star_last, None, _)
         _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
-            data = '"'
+            data = b'"'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
                 _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1405,7 +1405,7 @@ def rule_nextname(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '.'
+    data = b'.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1423,7 +1423,7 @@ def rule_wvar(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'W['
+    data = b'W['
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1437,7 +1437,7 @@ def rule_wvar(parse_state):
             _ = ERROR
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            data = ']'
+            data = b']'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
                 _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1476,7 +1476,7 @@ def rule_stringend(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '"'
+    data = b'"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1517,7 +1517,7 @@ def rule_quote(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '\''
+    data = b'\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1533,7 +1533,7 @@ def rule_innercharstring(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '\\\''
+    data = b'\\\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1591,7 +1591,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'a'
+    data = b'a'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1603,7 +1603,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'b'
+    data = b'b'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1615,7 +1615,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'c'
+    data = b'c'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1627,7 +1627,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'd'
+    data = b'd'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1639,7 +1639,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'e'
+    data = b'e'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1651,7 +1651,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'f'
+    data = b'f'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1663,7 +1663,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'g'
+    data = b'g'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1675,7 +1675,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'h'
+    data = b'h'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1687,7 +1687,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'i'
+    data = b'i'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1699,7 +1699,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'j'
+    data = b'j'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1711,7 +1711,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'k'
+    data = b'k'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1723,7 +1723,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'l'
+    data = b'l'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1735,7 +1735,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'm'
+    data = b'm'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1747,7 +1747,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'n'
+    data = b'n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1759,7 +1759,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'o'
+    data = b'o'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1771,7 +1771,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'p'
+    data = b'p'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1783,7 +1783,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'q'
+    data = b'q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1795,7 +1795,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'r'
+    data = b'r'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1807,7 +1807,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 's'
+    data = b's'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1819,7 +1819,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 't'
+    data = b't'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1831,7 +1831,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'u'
+    data = b'u'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1843,7 +1843,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'v'
+    data = b'v'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1855,7 +1855,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'w'
+    data = b'w'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1867,7 +1867,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'x'
+    data = b'x'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1879,7 +1879,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'y'
+    data = b'y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1891,7 +1891,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'z'
+    data = b'z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1903,7 +1903,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'A'
+    data = b'A'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1915,7 +1915,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'B'
+    data = b'B'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1927,7 +1927,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'C'
+    data = b'C'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1939,7 +1939,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'D'
+    data = b'D'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1951,7 +1951,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'E'
+    data = b'E'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1963,7 +1963,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'F'
+    data = b'F'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1975,7 +1975,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'G'
+    data = b'G'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1987,7 +1987,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'H'
+    data = b'H'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -1999,7 +1999,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'I'
+    data = b'I'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2011,7 +2011,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'J'
+    data = b'J'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2023,7 +2023,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'K'
+    data = b'K'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2035,7 +2035,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'L'
+    data = b'L'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2047,7 +2047,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'M'
+    data = b'M'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2059,7 +2059,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'N'
+    data = b'N'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2071,7 +2071,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'O'
+    data = b'O'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2083,7 +2083,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'P'
+    data = b'P'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2095,7 +2095,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'Q'
+    data = b'Q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2107,7 +2107,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'R'
+    data = b'R'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2119,7 +2119,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'S'
+    data = b'S'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2131,7 +2131,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'T'
+    data = b'T'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2143,7 +2143,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'U'
+    data = b'U'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2155,7 +2155,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'V'
+    data = b'V'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2167,7 +2167,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'W'
+    data = b'W'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2179,7 +2179,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'X'
+    data = b'X'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2191,7 +2191,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'Y'
+    data = b'Y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2203,7 +2203,7 @@ def rule_char(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = 'Z'
+    data = b'Z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2240,7 +2240,7 @@ def rule_spacechar(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = ' '
+    data = b' '
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2252,7 +2252,7 @@ def rule_spacechar(parse_state):
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    data = '\n'
+    data = b'\n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
         _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
@@ -2263,7 +2263,7 @@ def rule_spacechar(parse_state):
     return ERROR
 
 if __name__ == '__main__':
-    parse_state = ParseState(sys.stdin.read())
+    parse_state = ParseState(sys.stdin.buffer.read())
     runtime = Runtime()
     run_action(rule_main(parse_state), runtime)
     for chunk_buffer, action in runtime.placeholders:
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index a643095..d055dab 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -109,17 +109,17 @@ file = rule*:xs space !. -> {
         "return value + amount\n"
     <
     "\n"
-    "def render_chunk_buffer(chunk_buffer, last_char='\\n', indent=0):\n" >
+    "def render_chunk_buffer(chunk_buffer, last_char=b'\\n', indent=0):\n" >
         "if chunk_buffer:\n" >
             "chunk = chunk_buffer.pre_start.next\n"
             "while chunk:\n" >
                 "indent += chunk.indentation_delta\n"
                 "for char in chunk.data:\n" >
-                    "if last_char == '\\n':\n" >
-                        "sys.stdout.write('    '*indent)\n"
+                    "if last_char == b'\\n':\n" >
+                        "sys.stdout.buffer.write(b'    '*indent)\n"
                     <
-                    "last_char = char\n"
-                    "sys.stdout.write(last_char)\n"
+                    "last_char = char.to_bytes()\n"
+                    "sys.stdout.buffer.write(last_char)\n"
                 <
                 "last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n"
                 "chunk = chunk.next\n"
@@ -134,7 +134,7 @@ file = rule*:xs space !. -> {
     <placeholder
     xs
     "if __name__ == '__main__':\n" >
-        "parse_state = ParseState(sys.stdin.read())\n"
+        "parse_state = ParseState(sys.stdin.buffer.read())\n"
         "runtime = Runtime()\n"
         "run_action(rule_main(parse_state), runtime)\n"
         "for chunk_buffer, action in runtime.placeholders:\n" >
@@ -238,7 +238,7 @@ matchExprPrimitive =
         <
     }
     | charstring:x -> {
-        "data = " x "\n"
+        "data = b" x "\n"
         "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n" >
             "parse_state.pos += len(data)\n"
             "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n"
@@ -280,10 +280,10 @@ actionexpr =
     | space '<' name:x -> {
         "new_chunk_buffer = ChunkBuffer()\n"
         "runtime." x "_chunk_buffer = new_chunk_buffer\n"
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n"
     }
     | space expr:x -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(" x "), 0)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(" x ").encode('ascii'), 0)\n"
     }
     | space name:x -> {
         "run_action(lookup_action(variable, '" x "'), runtime)\n"
@@ -299,18 +299,18 @@ actionexpr =
         }
         "new_chunk_buffer = ChunkBuffer()\n"
         "runtime.placeholders.append((new_chunk_buffer, Action(placeholder_" W[1] ", variable, '', 0, 0)))\n"
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 0, new_chunk_buffer)\n"
     }
     | space string:x -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, " x ", 0)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b" x ", 0)\n"
     }
     | space '#' name:x '(' wvar:y ' ' actionPrimitiveExpression:z ')' -> {
         "runtime.W[" y "] = " x "(runtime.W.get(" y ", 0), " z ")\n"
     }
     | space '>' actionexpr*:xs space '<' -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', 1)\n"
         xs
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b'', -1)\n"
     }
     ;
 
@@ -334,7 +334,7 @@ digit =
 
 placeholder
     = '{' space string:x '*' expr:y space '}' -> {
-        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, " x "*" y ", 0)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, b" x "*" y ", 0)\n"
     }
     ;
 

2025-10-29 21:15 Rickard pushed to rlmeta2

commit 8560486c9da398e30760accec6ed25dd7c3b5cc5
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:55:54 2025 +0100

    More clear order of arguments for Action (input_buffer relates to start+end)

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 8150b9a..857a421 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -16,7 +16,7 @@ class Runtime:
         self.W = {}
 
 class Action:
-    def __init__(self, input_buffer, function, variable, start, end):
+    def __init__(self, function, variable, input_buffer, start, end):
         self.function = function
         self.variable = variable
         self.input_buffer = input_buffer
@@ -132,7 +132,7 @@ def action_2(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Action:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self, input_buffer, function, variable, start, end):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self, function, variable, input_buffer, start, end):\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.function = function\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.variable = variable\n", 0)
@@ -374,7 +374,7 @@ def action_14(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_last = append_named_action(star_last, None, _)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variable):
     pass
@@ -391,7 +391,7 @@ def action_17(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if parse_state.pos != len(parse_state.input_buffer):\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos += 1\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
@@ -406,7 +406,7 @@ def action_18(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos += len(data)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
@@ -428,13 +428,13 @@ def action_19(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(parse_state.input_buffer, action_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(action_", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", pre_first_variable.next, action_start_pos, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n", 0)
 
 def action_21(runtime, variable):
     pass
@@ -489,9 +489,9 @@ def action_25(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.placeholders.append((new_chunk_buffer, Action('', placeholder_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.placeholders.append((new_chunk_buffer, Action(placeholder_", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", variable, 0, 0)))\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", variable, '', 0, 0)))\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
 
 def action_26(runtime, variable):
@@ -568,7 +568,7 @@ def rule_main(parse_state):
     _ = rule_file(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_1, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_1, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_file(parse_state):
@@ -587,7 +587,7 @@ def rule_file(parse_state):
             parse_state.pos = star_pos
             break
         star_last = append_named_action(star_last, None, _)
-    _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+    _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
     last_variable = append_named_action(last_variable, 'xs', _)
     if _ != ERROR:
         _ = rule_space(parse_state)
@@ -595,7 +595,7 @@ def rule_file(parse_state):
             nlookahead_pos = parse_state.pos
             if parse_state.pos != len(parse_state.input_buffer):
                 parse_state.pos += 1
-                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
+                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
             else:
                 _ = ERROR
             if _ == ERROR:
@@ -604,7 +604,7 @@ def rule_file(parse_state):
                 _ = ERROR
             parse_state.pos = nlookahead_pos
             if _ != ERROR:
-                return Action(parse_state.input_buffer, action_2, pre_first_variable.next, action_start_pos, parse_state.pos)
+                return Action(action_2, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_rule(parse_state):
@@ -623,7 +623,7 @@ def rule_rule(parse_state):
                 data = '='
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -637,11 +637,11 @@ def rule_rule(parse_state):
                                 data = ';'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
-                                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(parse_state.input_buffer, action_3, pre_first_variable.next, action_start_pos, parse_state.pos)
+                                    return Action(action_3, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_ors(parse_state):
@@ -665,10 +665,10 @@ def rule_ors(parse_state):
                     parse_state.pos = star_pos
                     break
                 star_last = append_named_action(star_last, None, _)
-            _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+            _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
-                return Action(parse_state.input_buffer, action_4, pre_first_variable.next, action_start_pos, parse_state.pos)
+                return Action(action_4, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_restorcase(parse_state):
@@ -682,7 +682,7 @@ def rule_restorcase(parse_state):
         _ = rule_orcase(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_5, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_5, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_maybeorbar(parse_state):
@@ -693,12 +693,12 @@ def rule_maybeorbar(parse_state):
     last_variable = pre_first_variable
     _ = rule_orbar(parse_state)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(parse_state.input_buffer, action_6, pre_first_variable.next, action_start_pos, parse_state.pos)
+    return Action(action_6, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_orbar(parse_state):
@@ -712,11 +712,11 @@ def rule_orbar(parse_state):
         data = '|'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_orcase(parse_state):
@@ -728,7 +728,7 @@ def rule_orcase(parse_state):
     _ = rule_matchAnd(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_7, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_7, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAnd(parse_state):
@@ -745,7 +745,7 @@ def rule_matchAnd(parse_state):
             _ = rule_matchAnd(parse_state)
             last_variable = append_named_action(last_variable, 'y', _)
             if _ != ERROR:
-                return Action(parse_state.input_buffer, action_8, pre_first_variable.next, action_start_pos, parse_state.pos)
+                return Action(action_8, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -753,7 +753,7 @@ def rule_matchAnd(parse_state):
     _ = rule_action(parse_state)
     last_variable = append_named_action(last_variable, 'y', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_9, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_9, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExpr(parse_state):
@@ -765,14 +765,14 @@ def rule_matchExpr(parse_state):
     data = '!'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_matchExprPrimitive(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_10, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_10, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -783,7 +783,7 @@ def rule_matchExpr(parse_state):
         _ = rule_matchAssign(parse_state)
         last_variable = append_named_action(last_variable, 'y', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_11, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_11, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchAssign(parse_state):
@@ -795,19 +795,19 @@ def rule_matchAssign(parse_state):
     data = ':'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_name(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_12, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_12, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(parse_state.input_buffer, action_13, pre_first_variable.next, action_start_pos, parse_state.pos)
+    return Action(action_13, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprRepeat(parse_state):
@@ -822,11 +822,11 @@ def rule_matchExprRepeat(parse_state):
         data = '*'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_14, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_14, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -834,7 +834,7 @@ def rule_matchExprRepeat(parse_state):
     _ = rule_matchExprPrimitive(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_15, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_15, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_matchExprPrimitive(parse_state):
@@ -846,7 +846,7 @@ def rule_matchExprPrimitive(parse_state):
     _ = rule_name(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_16, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_16, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -854,11 +854,11 @@ def rule_matchExprPrimitive(parse_state):
     data = '.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_17, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_17, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -866,7 +866,7 @@ def rule_matchExprPrimitive(parse_state):
     _ = rule_charstring(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_18, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_18, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_action(parse_state):
@@ -880,7 +880,7 @@ def rule_action(parse_state):
         data = '->'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -889,7 +889,7 @@ def rule_action(parse_state):
                 data = '{'
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -903,7 +903,7 @@ def rule_action(parse_state):
                             parse_state.pos = star_pos
                             break
                         star_last = append_named_action(star_last, None, _)
-                    _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+                    _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
                     last_variable = append_named_action(last_variable, 'xs', _)
                     if _ != ERROR:
                         _ = rule_space(parse_state)
@@ -911,16 +911,16 @@ def rule_action(parse_state):
                             data = '}'
                             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                 parse_state.pos += len(data)
-                                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(parse_state.input_buffer, action_19, pre_first_variable.next, action_start_pos, parse_state.pos)
+                                return Action(action_19, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(parse_state.input_buffer, action_20, pre_first_variable.next, action_start_pos, parse_state.pos)
+    return Action(action_20, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionexpr(parse_state):
@@ -934,7 +934,7 @@ def rule_actionexpr(parse_state):
         data = '>'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -946,7 +946,7 @@ def rule_actionexpr(parse_state):
                     data = '{'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
-                        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
@@ -960,7 +960,7 @@ def rule_actionexpr(parse_state):
                                 parse_state.pos = star_pos
                                 break
                             star_last = append_named_action(star_last, None, _)
-                        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+                        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
                         last_variable = append_named_action(last_variable, 'ys', _)
                         if _ != ERROR:
                             _ = rule_space(parse_state)
@@ -968,11 +968,11 @@ def rule_actionexpr(parse_state):
                                 data = '}'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
-                                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(parse_state.input_buffer, action_21, pre_first_variable.next, action_start_pos, parse_state.pos)
+                                    return Action(action_21, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -982,14 +982,14 @@ def rule_actionexpr(parse_state):
         data = '<'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
             _ = rule_name(parse_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
-                return Action(parse_state.input_buffer, action_22, pre_first_variable.next, action_start_pos, parse_state.pos)
+                return Action(action_22, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -999,7 +999,7 @@ def rule_actionexpr(parse_state):
         _ = rule_expr(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_23, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_23, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1009,7 +1009,7 @@ def rule_actionexpr(parse_state):
         _ = rule_name(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_24, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_24, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1019,7 +1019,7 @@ def rule_actionexpr(parse_state):
         _ = rule_placeholder(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_25, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_25, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1029,7 +1029,7 @@ def rule_actionexpr(parse_state):
         _ = rule_string(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_26, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_26, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1039,7 +1039,7 @@ def rule_actionexpr(parse_state):
         data = '#'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -1049,7 +1049,7 @@ def rule_actionexpr(parse_state):
                 data = '('
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -1059,7 +1059,7 @@ def rule_actionexpr(parse_state):
                         data = ' '
                         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                             parse_state.pos += len(data)
-                            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                         else:
                             _ = ERROR
                         if _ != ERROR:
@@ -1069,11 +1069,11 @@ def rule_actionexpr(parse_state):
                                 data = ')'
                                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                     parse_state.pos += len(data)
-                                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(parse_state.input_buffer, action_27, pre_first_variable.next, action_start_pos, parse_state.pos)
+                                    return Action(action_27, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1083,7 +1083,7 @@ def rule_actionexpr(parse_state):
         data = '>'
         if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
             parse_state.pos += len(data)
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -1097,7 +1097,7 @@ def rule_actionexpr(parse_state):
                     parse_state.pos = star_pos
                     break
                 star_last = append_named_action(star_last, None, _)
-            _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+            _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
                 _ = rule_space(parse_state)
@@ -1105,11 +1105,11 @@ def rule_actionexpr(parse_state):
                     data = '<'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
-                        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(parse_state.input_buffer, action_28, pre_first_variable.next, action_start_pos, parse_state.pos)
+                        return Action(action_28, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_actionPrimitiveExpression(parse_state):
@@ -1121,14 +1121,14 @@ def rule_actionPrimitiveExpression(parse_state):
     _ = rule_dotname(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_29, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_29, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     _ = rule_digit(parse_state)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_digit(parse_state):
@@ -1140,11 +1140,11 @@ def rule_digit(parse_state):
     data = '0'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1152,11 +1152,11 @@ def rule_digit(parse_state):
     data = '1'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1164,11 +1164,11 @@ def rule_digit(parse_state):
     data = '2'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1176,11 +1176,11 @@ def rule_digit(parse_state):
     data = '3'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1188,11 +1188,11 @@ def rule_digit(parse_state):
     data = '4'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1200,11 +1200,11 @@ def rule_digit(parse_state):
     data = '5'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1212,11 +1212,11 @@ def rule_digit(parse_state):
     data = '6'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1224,11 +1224,11 @@ def rule_digit(parse_state):
     data = '7'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1236,11 +1236,11 @@ def rule_digit(parse_state):
     data = '8'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1248,11 +1248,11 @@ def rule_digit(parse_state):
     data = '9'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_placeholder(parse_state):
@@ -1264,7 +1264,7 @@ def rule_placeholder(parse_state):
     data = '{'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1276,7 +1276,7 @@ def rule_placeholder(parse_state):
                 data = '*'
                 if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                     parse_state.pos += len(data)
-                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                    _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -1288,11 +1288,11 @@ def rule_placeholder(parse_state):
                             data = '}'
                             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                                 parse_state.pos += len(data)
-                                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(parse_state.input_buffer, action_30, pre_first_variable.next, action_start_pos, parse_state.pos)
+                                return Action(action_30, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_expr(parse_state):
@@ -1304,7 +1304,7 @@ def rule_expr(parse_state):
     _ = rule_wvar(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_31, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_31, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1312,7 +1312,7 @@ def rule_expr(parse_state):
     data = '('
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1322,7 +1322,7 @@ def rule_expr(parse_state):
             data = '-'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
-                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
@@ -1332,11 +1332,11 @@ def rule_expr(parse_state):
                     data = ')'
                     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                         parse_state.pos += len(data)
-                        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(parse_state.input_buffer, action_32, pre_first_variable.next, action_start_pos, parse_state.pos)
+                        return Action(action_32, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_string(parse_state):
@@ -1348,7 +1348,7 @@ def rule_string(parse_state):
     data = '"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1362,16 +1362,16 @@ def rule_string(parse_state):
                 parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             data = '"'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
-                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+                return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_dotname(parse_state):
@@ -1393,10 +1393,10 @@ def rule_dotname(parse_state):
                 parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         last_variable = append_named_action(last_variable, 'xs', _)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, action_33, pre_first_variable.next, action_start_pos, parse_state.pos)
+            return Action(action_33, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_nextname(parse_state):
@@ -1408,13 +1408,13 @@ def rule_nextname(parse_state):
     data = '.'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_name(parse_state)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_wvar(parse_state):
@@ -1426,13 +1426,13 @@ def rule_wvar(parse_state):
     data = 'W['
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         if parse_state.pos != len(parse_state.input_buffer):
             parse_state.pos += 1
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         last_variable = append_named_action(last_variable, 'x', _)
@@ -1440,11 +1440,11 @@ def rule_wvar(parse_state):
             data = ']'
             if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
                 parse_state.pos += len(data)
-                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+                _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(parse_state.input_buffer, action_34, pre_first_variable.next, action_start_pos, parse_state.pos)
+                return Action(action_34, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringinner(parse_state):
@@ -1463,11 +1463,11 @@ def rule_stringinner(parse_state):
     if _ != ERROR:
         if parse_state.pos != len(parse_state.input_buffer):
             parse_state.pos += 1
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_stringend(parse_state):
@@ -1479,11 +1479,11 @@ def rule_stringend(parse_state):
     data = '"'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_charstring(parse_state):
@@ -1504,11 +1504,11 @@ def rule_charstring(parse_state):
                 parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
             _ = rule_quote(parse_state)
             if _ != ERROR:
-                return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+                return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_quote(parse_state):
@@ -1520,11 +1520,11 @@ def rule_quote(parse_state):
     data = '\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_innercharstring(parse_state):
@@ -1536,11 +1536,11 @@ def rule_innercharstring(parse_state):
     data = '\\\''
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, action_35, pre_first_variable.next, action_start_pos, parse_state.pos)
+        return Action(action_35, pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1555,11 +1555,11 @@ def rule_innercharstring(parse_state):
     if _ != ERROR:
         if parse_state.pos != len(parse_state.input_buffer):
             parse_state.pos += 1
-            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
+            _ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_name(parse_state):
@@ -1580,9 +1580,9 @@ def rule_name(parse_state):
                 parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+        _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
         if _ != ERROR:
-            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+            return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_char(parse_state):
@@ -1594,11 +1594,11 @@ def rule_char(parse_state):
     data = 'a'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1606,11 +1606,11 @@ def rule_char(parse_state):
     data = 'b'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1618,11 +1618,11 @@ def rule_char(parse_state):
     data = 'c'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1630,11 +1630,11 @@ def rule_char(parse_state):
     data = 'd'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1642,11 +1642,11 @@ def rule_char(parse_state):
     data = 'e'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1654,11 +1654,11 @@ def rule_char(parse_state):
     data = 'f'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1666,11 +1666,11 @@ def rule_char(parse_state):
     data = 'g'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1678,11 +1678,11 @@ def rule_char(parse_state):
     data = 'h'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1690,11 +1690,11 @@ def rule_char(parse_state):
     data = 'i'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1702,11 +1702,11 @@ def rule_char(parse_state):
     data = 'j'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1714,11 +1714,11 @@ def rule_char(parse_state):
     data = 'k'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1726,11 +1726,11 @@ def rule_char(parse_state):
     data = 'l'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1738,11 +1738,11 @@ def rule_char(parse_state):
     data = 'm'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1750,11 +1750,11 @@ def rule_char(parse_state):
     data = 'n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1762,11 +1762,11 @@ def rule_char(parse_state):
     data = 'o'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1774,11 +1774,11 @@ def rule_char(parse_state):
     data = 'p'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1786,11 +1786,11 @@ def rule_char(parse_state):
     data = 'q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1798,11 +1798,11 @@ def rule_char(parse_state):
     data = 'r'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1810,11 +1810,11 @@ def rule_char(parse_state):
     data = 's'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1822,11 +1822,11 @@ def rule_char(parse_state):
     data = 't'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1834,11 +1834,11 @@ def rule_char(parse_state):
     data = 'u'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1846,11 +1846,11 @@ def rule_char(parse_state):
     data = 'v'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1858,11 +1858,11 @@ def rule_char(parse_state):
     data = 'w'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1870,11 +1870,11 @@ def rule_char(parse_state):
     data = 'x'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1882,11 +1882,11 @@ def rule_char(parse_state):
     data = 'y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1894,11 +1894,11 @@ def rule_char(parse_state):
     data = 'z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1906,11 +1906,11 @@ def rule_char(parse_state):
     data = 'A'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1918,11 +1918,11 @@ def rule_char(parse_state):
     data = 'B'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1930,11 +1930,11 @@ def rule_char(parse_state):
     data = 'C'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1942,11 +1942,11 @@ def rule_char(parse_state):
     data = 'D'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1954,11 +1954,11 @@ def rule_char(parse_state):
     data = 'E'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1966,11 +1966,11 @@ def rule_char(parse_state):
     data = 'F'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1978,11 +1978,11 @@ def rule_char(parse_state):
     data = 'G'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -1990,11 +1990,11 @@ def rule_char(parse_state):
     data = 'H'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2002,11 +2002,11 @@ def rule_char(parse_state):
     data = 'I'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2014,11 +2014,11 @@ def rule_char(parse_state):
     data = 'J'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2026,11 +2026,11 @@ def rule_char(parse_state):
     data = 'K'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2038,11 +2038,11 @@ def rule_char(parse_state):
     data = 'L'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2050,11 +2050,11 @@ def rule_char(parse_state):
     data = 'M'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2062,11 +2062,11 @@ def rule_char(parse_state):
     data = 'N'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2074,11 +2074,11 @@ def rule_char(parse_state):
     data = 'O'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2086,11 +2086,11 @@ def rule_char(parse_state):
     data = 'P'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2098,11 +2098,11 @@ def rule_char(parse_state):
     data = 'Q'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2110,11 +2110,11 @@ def rule_char(parse_state):
     data = 'R'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2122,11 +2122,11 @@ def rule_char(parse_state):
     data = 'S'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2134,11 +2134,11 @@ def rule_char(parse_state):
     data = 'T'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2146,11 +2146,11 @@ def rule_char(parse_state):
     data = 'U'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2158,11 +2158,11 @@ def rule_char(parse_state):
     data = 'V'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2170,11 +2170,11 @@ def rule_char(parse_state):
     data = 'W'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2182,11 +2182,11 @@ def rule_char(parse_state):
     data = 'X'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2194,11 +2194,11 @@ def rule_char(parse_state):
     data = 'Y'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2206,11 +2206,11 @@ def rule_char(parse_state):
     data = 'Z'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_space(parse_state):
@@ -2229,9 +2229,9 @@ def rule_space(parse_state):
             parse_state.pos = star_pos
             break
         star_last = append_named_action(star_last, None, _)
-    _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
+    _ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 def rule_spacechar(parse_state):
@@ -2243,11 +2243,11 @@ def rule_spacechar(parse_state):
     data = ' '
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     parse_state.pos = or_backtrack_pos
     action_start_pos = parse_state.pos
     pre_first_variable = Variable()
@@ -2255,11 +2255,11 @@ def rule_spacechar(parse_state):
     data = '\n'
     if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
         parse_state.pos += len(data)
-        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
+        _ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+        return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)
     return ERROR
 
 if __name__ == '__main__':
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 19b3fc3..a643095 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -21,7 +21,7 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "class Action:\n" >
-        "def __init__(self, input_buffer, function, variable, start, end):\n" >
+        "def __init__(self, function, variable, input_buffer, start, end):\n" >
             "self.function = function\n"
             "self.variable = variable\n"
             "self.input_buffer = input_buffer\n"
@@ -217,7 +217,7 @@ matchExprRepeat =
             <
             "star_last = append_named_action(star_last, None, _)\n"
         <
-        "_ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)\n"
+        "_ = Action(None, star_pre_first.next, parse_state.input_buffer, star_start_pos, parse_state.pos)\n"
     }
     | matchExprPrimitive:x -> {
         x
@@ -231,7 +231,7 @@ matchExprPrimitive =
     | '.'          -> {
         "if parse_state.pos != len(parse_state.input_buffer):\n" >
             "parse_state.pos += 1\n"
-            "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)\n"
+            "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-1, parse_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -241,7 +241,7 @@ matchExprPrimitive =
         "data = " x "\n"
         "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n" >
             "parse_state.pos += len(data)\n"
-            "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)\n"
+            "_ = Action(None, None, parse_state.input_buffer, parse_state.pos-len(data), parse_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -259,10 +259,10 @@ action =
             <
             "\n"
         }
-        "return Action(parse_state.input_buffer, action_" W[0] ", pre_first_variable.next, action_start_pos, parse_state.pos)\n"
+        "return Action(action_" W[0] ", pre_first_variable.next, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
     }
     | -> {
-        "return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)\n"
+        "return Action(None, None, parse_state.input_buffer, action_start_pos, parse_state.pos)\n"
     }
     ;
 
@@ -298,7 +298,7 @@ actionexpr =
             "\n"
         }
         "new_chunk_buffer = ChunkBuffer()\n"
-        "runtime.placeholders.append((new_chunk_buffer, Action('', placeholder_" W[1] ", variable, 0, 0)))\n"
+        "runtime.placeholders.append((new_chunk_buffer, Action(placeholder_" W[1] ", variable, '', 0, 0)))\n"
         "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
     }
     | space string:x -> {

2025-10-29 20:54 Rickard pushed to rlmeta2

commit 99ac7cf358e333fc1465837a10d81a5442d193d8
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:52:13 2025 +0100

    Split CompilerState into ParseState and Runtime

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index e78ba1d..8150b9a 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -1,9 +1,12 @@
 import sys
 
-class CompilerState:
+class ParseState:
     def __init__(self, input_buffer):
         self.input_buffer = input_buffer
         self.pos = 0
+
+class Runtime:
+    def __init__(self):
         self.output_chunk_buffer = ChunkBuffer()
         self.current_chunk_buffer = self.output_chunk_buffer
         self.action_chunk_buffer = None
@@ -104,12 +107,19 @@ def action_2(runtime, variable):
     pass
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "import sys\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class CompilerState:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class ParseState:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self, input_buffer):\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.pos = 0\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Runtime:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.output_chunk_buffer = ChunkBuffer()\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
     new_chunk_buffer = ChunkBuffer()
@@ -265,14 +275,15 @@ def action_2(runtime, variable):
     run_action(lookup_action(variable, 'xs'), runtime)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if __name__ == '__main__':\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state = CompilerState(sys.stdin.read())\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(rule_main(compiler_state), compiler_state)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "for chunk_buffer, action in compiler_state.placeholders:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state = ParseState(sys.stdin.read())\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime = Runtime()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(rule_main(parse_state), runtime)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "for chunk_buffer, action in runtime.placeholders:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = chunk_buffer\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(action, compiler_state)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer = chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(action, runtime)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "render_chunk_buffer(compiler_state.output_chunk_buffer)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "render_chunk_buffer(runtime.output_chunk_buffer)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
 
 def action_3(runtime, variable):
@@ -2252,9 +2263,10 @@ def rule_spacechar(parse_state):
     return ERROR
 
 if __name__ == '__main__':
-    compiler_state = CompilerState(sys.stdin.read())
-    run_action(rule_main(compiler_state), compiler_state)
-    for chunk_buffer, action in compiler_state.placeholders:
-        compiler_state.current_chunk_buffer = chunk_buffer
-        run_action(action, compiler_state)
-    render_chunk_buffer(compiler_state.output_chunk_buffer)
+    parse_state = ParseState(sys.stdin.read())
+    runtime = Runtime()
+    run_action(rule_main(parse_state), runtime)
+    for chunk_buffer, action in runtime.placeholders:
+        runtime.current_chunk_buffer = chunk_buffer
+        run_action(action, runtime)
+    render_chunk_buffer(runtime.output_chunk_buffer)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 343185a..19b3fc3 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -3,10 +3,15 @@ main = file:x -> { x };
 file = rule*:xs space !. -> {
     "import sys\n"
     "\n"
-    "class CompilerState:\n" >
+    "class ParseState:\n" >
         "def __init__(self, input_buffer):\n" >
             "self.input_buffer = input_buffer\n"
             "self.pos = 0\n"
+        <
+    <
+    "\n"
+    "class Runtime:\n" >
+        "def __init__(self):\n" >
             "self.output_chunk_buffer = ChunkBuffer()\n"
             "self.current_chunk_buffer = self.output_chunk_buffer\n"
             <namedBuffers
@@ -129,13 +134,14 @@ file = rule*:xs space !. -> {
     <placeholder
     xs
     "if __name__ == '__main__':\n" >
-        "compiler_state = CompilerState(sys.stdin.read())\n"
-        "run_action(rule_main(compiler_state), compiler_state)\n"
-        "for chunk_buffer, action in compiler_state.placeholders:\n" >
-            "compiler_state.current_chunk_buffer = chunk_buffer\n"
-            "run_action(action, compiler_state)\n"
+        "parse_state = ParseState(sys.stdin.read())\n"
+        "runtime = Runtime()\n"
+        "run_action(rule_main(parse_state), runtime)\n"
+        "for chunk_buffer, action in runtime.placeholders:\n" >
+            "runtime.current_chunk_buffer = chunk_buffer\n"
+            "run_action(action, runtime)\n"
         <
-        "render_chunk_buffer(compiler_state.output_chunk_buffer)\n"
+        "render_chunk_buffer(runtime.output_chunk_buffer)\n"
     <
 };
 

commit dd79bdcc76b4479050095ebd2da45ece7365dbc0
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:49:44 2025 +0100

    Better name parse state

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index ebf7c8d..e78ba1d 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -279,7 +279,7 @@ def action_3(runtime, variable):
     pass
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def rule_", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(compiler_state):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(parse_state):\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     run_action(lookup_action(variable, 'y'), runtime)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
@@ -287,7 +287,7 @@ def action_3(runtime, variable):
 
 def action_4(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "or_backtrack_pos = compiler_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "or_backtrack_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
     run_action(lookup_action(variable, 'xs'), runtime)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return ERROR\n", 0)
@@ -301,8 +301,8 @@ def action_6(runtime, variable):
 
 def action_7(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos = or_backtrack_pos\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "action_start_pos = compiler_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos = or_backtrack_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "action_start_pos = parse_state.pos\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "pre_first_variable = Variable()\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_variable = pre_first_variable\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
@@ -321,7 +321,7 @@ def action_9(runtime, variable):
 
 def action_10(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "nlookahead_pos = compiler_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "nlookahead_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
@@ -331,7 +331,7 @@ def action_10(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = ERROR\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos = nlookahead_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos = nlookahead_pos\n", 0)
 
 def action_11(runtime, variable):
     pass
@@ -351,19 +351,19 @@ def action_14(runtime, variable):
     pass
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_pre_first = Variable()\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_last = star_pre_first\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_start_pos = compiler_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_start_pos = parse_state.pos\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while True:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_pos = compiler_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_pos = parse_state.pos\n", 0)
     run_action(lookup_action(variable, 'x'), runtime)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos = star_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos = star_pos\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "break\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_last = append_named_action(star_last, None, _)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)\n", 0)
 
 def action_15(runtime, variable):
     pass
@@ -373,14 +373,14 @@ def action_16(runtime, variable):
     pass
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = rule_", 0)
     run_action(lookup_action(variable, 'x'), runtime)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(compiler_state)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(parse_state)\n", 0)
 
 def action_17(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if compiler_state.pos != len(compiler_state.input_buffer):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if parse_state.pos != len(parse_state.input_buffer):\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos += 1\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos += 1\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
@@ -392,10 +392,10 @@ def action_18(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "data = ", 0)
     run_action(lookup_action(variable, 'x'), runtime)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos += len(data)\n", 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "parse_state.pos += len(data)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
@@ -417,13 +417,13 @@ def action_19(runtime, variable):
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
     runtime.current_chunk_buffer = last_chunk_buffer
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, action_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(parse_state.input_buffer, action_", 0)
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)), 0)
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", pre_first_variable.next, action_start_pos, compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", pre_first_variable.next, action_start_pos, parse_state.pos)\n", 0)
 
 def action_20(runtime, variable):
     pass
-    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)\n", 0)
 
 def action_21(runtime, variable):
     pass
@@ -548,1707 +548,1707 @@ def action_35(runtime, variable):
     pass
     runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "'", 0)
 
-def rule_main(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_main(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_file(compiler_state)
+    _ = rule_file(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_1, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, action_1, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_file(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_file(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     star_pre_first = Variable()
     star_last = star_pre_first
-    star_start_pos = compiler_state.pos
+    star_start_pos = parse_state.pos
     while True:
-        star_pos = compiler_state.pos
-        _ = rule_rule(compiler_state)
+        star_pos = parse_state.pos
+        _ = rule_rule(parse_state)
         if _ == ERROR:
-            compiler_state.pos = star_pos
+            parse_state.pos = star_pos
             break
         star_last = append_named_action(star_last, None, _)
-    _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+    _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
     last_variable = append_named_action(last_variable, 'xs', _)
     if _ != ERROR:
-        _ = rule_space(compiler_state)
+        _ = rule_space(parse_state)
         if _ != ERROR:
-            nlookahead_pos = compiler_state.pos
-            if compiler_state.pos != len(compiler_state.input_buffer):
-                compiler_state.pos += 1
-                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+            nlookahead_pos = parse_state.pos
+            if parse_state.pos != len(parse_state.input_buffer):
+                parse_state.pos += 1
+                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
             else:
                 _ = ERROR
             if _ == ERROR:
                 _ = lambda: None
             else:
                 _ = ERROR
-            compiler_state.pos = nlookahead_pos
+            parse_state.pos = nlookahead_pos
             if _ != ERROR:
-                return Action(compiler_state.input_buffer, action_2, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(parse_state.input_buffer, action_2, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_rule(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_rule(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
-        _ = rule_name(compiler_state)
+        _ = rule_name(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            _ = rule_space(compiler_state)
+            _ = rule_space(parse_state)
             if _ != ERROR:
                 data = '='
-                if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                    compiler_state.pos += len(data)
-                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
-                    _ = rule_space(compiler_state)
+                    _ = rule_space(parse_state)
                     if _ != ERROR:
-                        _ = rule_ors(compiler_state)
+                        _ = rule_ors(parse_state)
                         last_variable = append_named_action(last_variable, 'y', _)
                         if _ != ERROR:
-                            _ = rule_space(compiler_state)
+                            _ = rule_space(parse_state)
                             if _ != ERROR:
                                 data = ';'
-                                if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                                    compiler_state.pos += len(data)
-                                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                    parse_state.pos += len(data)
+                                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(compiler_state.input_buffer, action_3, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                                    return Action(parse_state.input_buffer, action_3, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_ors(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_ors(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_maybeorbar(compiler_state)
+    _ = rule_maybeorbar(parse_state)
     if _ != ERROR:
-        _ = rule_orcase(compiler_state)
+        _ = rule_orcase(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
             star_pre_first = Variable()
             star_last = star_pre_first
-            star_start_pos = compiler_state.pos
+            star_start_pos = parse_state.pos
             while True:
-                star_pos = compiler_state.pos
-                _ = rule_restorcase(compiler_state)
+                star_pos = parse_state.pos
+                _ = rule_restorcase(parse_state)
                 if _ == ERROR:
-                    compiler_state.pos = star_pos
+                    parse_state.pos = star_pos
                     break
                 star_last = append_named_action(star_last, None, _)
-            _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+            _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
-                return Action(compiler_state.input_buffer, action_4, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(parse_state.input_buffer, action_4, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_restorcase(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_restorcase(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_orbar(compiler_state)
+    _ = rule_orbar(parse_state)
     if _ != ERROR:
-        _ = rule_orcase(compiler_state)
+        _ = rule_orcase(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_5, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, action_5, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_maybeorbar(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_maybeorbar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_orbar(compiler_state)
+    _ = rule_orbar(parse_state)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(compiler_state.input_buffer, action_6, pre_first_variable.next, action_start_pos, compiler_state.pos)
+    return Action(parse_state.input_buffer, action_6, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_orbar(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_orbar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
         data = '|'
-        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-            compiler_state.pos += len(data)
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_orcase(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_orcase(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_matchAnd(compiler_state)
+    _ = rule_matchAnd(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_7, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, action_7, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_matchAnd(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_matchAnd(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
-        _ = rule_matchExpr(compiler_state)
+        _ = rule_matchExpr(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            _ = rule_matchAnd(compiler_state)
+            _ = rule_matchAnd(parse_state)
             last_variable = append_named_action(last_variable, 'y', _)
             if _ != ERROR:
-                return Action(compiler_state.input_buffer, action_8, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+                return Action(parse_state.input_buffer, action_8, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_action(compiler_state)
+    _ = rule_action(parse_state)
     last_variable = append_named_action(last_variable, 'y', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_9, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, action_9, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_matchExpr(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_matchExpr(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '!'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        _ = rule_matchExprPrimitive(compiler_state)
+        _ = rule_matchExprPrimitive(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_10, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+            return Action(parse_state.input_buffer, action_10, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_matchExprRepeat(compiler_state)
+    _ = rule_matchExprRepeat(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        _ = rule_matchAssign(compiler_state)
+        _ = rule_matchAssign(parse_state)
         last_variable = append_named_action(last_variable, 'y', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_11, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, action_11, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_matchAssign(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_matchAssign(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = ':'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        _ = rule_name(compiler_state)
+        _ = rule_name(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_12, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+            return Action(parse_state.input_buffer, action_12, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(compiler_state.input_buffer, action_13, pre_first_variable.next, action_start_pos, compiler_state.pos)
+    return Action(parse_state.input_buffer, action_13, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_matchExprRepeat(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_matchExprRepeat(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_matchExprPrimitive(compiler_state)
+    _ = rule_matchExprPrimitive(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
         data = '*'
-        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-            compiler_state.pos += len(data)
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_14, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+            return Action(parse_state.input_buffer, action_14, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_matchExprPrimitive(compiler_state)
+    _ = rule_matchExprPrimitive(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_15, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, action_15, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_matchExprPrimitive(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_matchExprPrimitive(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_name(compiler_state)
+    _ = rule_name(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_16, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, action_16, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '.'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_17, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, action_17, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_charstring(compiler_state)
+    _ = rule_charstring(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_18, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, action_18, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_action(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_action(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
         data = '->'
-        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-            compiler_state.pos += len(data)
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            _ = rule_space(compiler_state)
+            _ = rule_space(parse_state)
             if _ != ERROR:
                 data = '{'
-                if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                    compiler_state.pos += len(data)
-                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
                     star_pre_first = Variable()
                     star_last = star_pre_first
-                    star_start_pos = compiler_state.pos
+                    star_start_pos = parse_state.pos
                     while True:
-                        star_pos = compiler_state.pos
-                        _ = rule_actionexpr(compiler_state)
+                        star_pos = parse_state.pos
+                        _ = rule_actionexpr(parse_state)
                         if _ == ERROR:
-                            compiler_state.pos = star_pos
+                            parse_state.pos = star_pos
                             break
                         star_last = append_named_action(star_last, None, _)
-                    _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+                    _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
                     last_variable = append_named_action(last_variable, 'xs', _)
                     if _ != ERROR:
-                        _ = rule_space(compiler_state)
+                        _ = rule_space(parse_state)
                         if _ != ERROR:
                             data = '}'
-                            if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                                compiler_state.pos += len(data)
-                                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                parse_state.pos += len(data)
+                                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(compiler_state.input_buffer, action_19, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+                                return Action(parse_state.input_buffer, action_19, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(compiler_state.input_buffer, action_20, pre_first_variable.next, action_start_pos, compiler_state.pos)
+    return Action(parse_state.input_buffer, action_20, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_actionexpr(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_actionexpr(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
         data = '>'
-        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-            compiler_state.pos += len(data)
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            _ = rule_name(compiler_state)
+            _ = rule_name(parse_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
-                _ = rule_space(compiler_state)
+                _ = rule_space(parse_state)
                 if _ != ERROR:
                     data = '{'
-                    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                        compiler_state.pos += len(data)
-                        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                        parse_state.pos += len(data)
+                        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
                         star_pre_first = Variable()
                         star_last = star_pre_first
-                        star_start_pos = compiler_state.pos
+                        star_start_pos = parse_state.pos
                         while True:
-                            star_pos = compiler_state.pos
-                            _ = rule_actionexpr(compiler_state)
+                            star_pos = parse_state.pos
+                            _ = rule_actionexpr(parse_state)
                             if _ == ERROR:
-                                compiler_state.pos = star_pos
+                                parse_state.pos = star_pos
                                 break
                             star_last = append_named_action(star_last, None, _)
-                        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+                        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
                         last_variable = append_named_action(last_variable, 'ys', _)
                         if _ != ERROR:
-                            _ = rule_space(compiler_state)
+                            _ = rule_space(parse_state)
                             if _ != ERROR:
                                 data = '}'
-                                if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                                    compiler_state.pos += len(data)
-                                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                    parse_state.pos += len(data)
+                                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(compiler_state.input_buffer, action_21, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+                                    return Action(parse_state.input_buffer, action_21, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
         data = '<'
-        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-            compiler_state.pos += len(data)
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            _ = rule_name(compiler_state)
+            _ = rule_name(parse_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
-                return Action(compiler_state.input_buffer, action_22, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+                return Action(parse_state.input_buffer, action_22, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
-        _ = rule_expr(compiler_state)
+        _ = rule_expr(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_23, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+            return Action(parse_state.input_buffer, action_23, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
-        _ = rule_name(compiler_state)
+        _ = rule_name(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_24, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+            return Action(parse_state.input_buffer, action_24, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
-        _ = rule_placeholder(compiler_state)
+        _ = rule_placeholder(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_25, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+            return Action(parse_state.input_buffer, action_25, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
-        _ = rule_string(compiler_state)
+        _ = rule_string(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_26, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+            return Action(parse_state.input_buffer, action_26, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
         data = '#'
-        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-            compiler_state.pos += len(data)
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            _ = rule_name(compiler_state)
+            _ = rule_name(parse_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
                 data = '('
-                if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                    compiler_state.pos += len(data)
-                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
-                    _ = rule_wvar(compiler_state)
+                    _ = rule_wvar(parse_state)
                     last_variable = append_named_action(last_variable, 'y', _)
                     if _ != ERROR:
                         data = ' '
-                        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                            compiler_state.pos += len(data)
-                            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                            parse_state.pos += len(data)
+                            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                         else:
                             _ = ERROR
                         if _ != ERROR:
-                            _ = rule_actionPrimitiveExpression(compiler_state)
+                            _ = rule_actionPrimitiveExpression(parse_state)
                             last_variable = append_named_action(last_variable, 'z', _)
                             if _ != ERROR:
                                 data = ')'
-                                if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                                    compiler_state.pos += len(data)
-                                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                    parse_state.pos += len(data)
+                                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(compiler_state.input_buffer, action_27, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+                                    return Action(parse_state.input_buffer, action_27, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_space(compiler_state)
+    _ = rule_space(parse_state)
     if _ != ERROR:
         data = '>'
-        if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-            compiler_state.pos += len(data)
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+            parse_state.pos += len(data)
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
             star_pre_first = Variable()
             star_last = star_pre_first
-            star_start_pos = compiler_state.pos
+            star_start_pos = parse_state.pos
             while True:
-                star_pos = compiler_state.pos
-                _ = rule_actionexpr(compiler_state)
+                star_pos = parse_state.pos
+                _ = rule_actionexpr(parse_state)
                 if _ == ERROR:
-                    compiler_state.pos = star_pos
+                    parse_state.pos = star_pos
                     break
                 star_last = append_named_action(star_last, None, _)
-            _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+            _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
-                _ = rule_space(compiler_state)
+                _ = rule_space(parse_state)
                 if _ != ERROR:
                     data = '<'
-                    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                        compiler_state.pos += len(data)
-                        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                        parse_state.pos += len(data)
+                        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(compiler_state.input_buffer, action_28, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                        return Action(parse_state.input_buffer, action_28, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_actionPrimitiveExpression(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_actionPrimitiveExpression(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_dotname(compiler_state)
+    _ = rule_dotname(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_29, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, action_29, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_digit(compiler_state)
+    _ = rule_digit(parse_state)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_digit(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_digit(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '0'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '1'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '2'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '3'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '4'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '5'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '6'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '7'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '8'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '9'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_placeholder(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_placeholder(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '{'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        _ = rule_space(compiler_state)
+        _ = rule_space(parse_state)
         if _ != ERROR:
-            _ = rule_string(compiler_state)
+            _ = rule_string(parse_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
                 data = '*'
-                if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                    compiler_state.pos += len(data)
-                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                    parse_state.pos += len(data)
+                    _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
-                    _ = rule_expr(compiler_state)
+                    _ = rule_expr(parse_state)
                     last_variable = append_named_action(last_variable, 'y', _)
                     if _ != ERROR:
-                        _ = rule_space(compiler_state)
+                        _ = rule_space(parse_state)
                         if _ != ERROR:
                             data = '}'
-                            if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                                compiler_state.pos += len(data)
-                                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                                parse_state.pos += len(data)
+                                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(compiler_state.input_buffer, action_30, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                                return Action(parse_state.input_buffer, action_30, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_expr(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_expr(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_wvar(compiler_state)
+    _ = rule_wvar(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_31, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, action_31, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '('
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        _ = rule_wvar(compiler_state)
+        _ = rule_wvar(parse_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
             data = '-'
-            if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                compiler_state.pos += len(data)
-                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                parse_state.pos += len(data)
+                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                _ = rule_dotname(compiler_state)
+                _ = rule_dotname(parse_state)
                 last_variable = append_named_action(last_variable, 'y', _)
                 if _ != ERROR:
                     data = ')'
-                    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                        compiler_state.pos += len(data)
-                        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                        parse_state.pos += len(data)
+                        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(compiler_state.input_buffer, action_32, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                        return Action(parse_state.input_buffer, action_32, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_string(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_string(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '"'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         star_pre_first = Variable()
         star_last = star_pre_first
-        star_start_pos = compiler_state.pos
+        star_start_pos = parse_state.pos
         while True:
-            star_pos = compiler_state.pos
-            _ = rule_stringinner(compiler_state)
+            star_pos = parse_state.pos
+            _ = rule_stringinner(parse_state)
             if _ == ERROR:
-                compiler_state.pos = star_pos
+                parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
         if _ != ERROR:
             data = '"'
-            if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                compiler_state.pos += len(data)
-                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                parse_state.pos += len(data)
+                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+                return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_dotname(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_dotname(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_name(compiler_state)
+    _ = rule_name(parse_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
         star_pre_first = Variable()
         star_last = star_pre_first
-        star_start_pos = compiler_state.pos
+        star_start_pos = parse_state.pos
         while True:
-            star_pos = compiler_state.pos
-            _ = rule_nextname(compiler_state)
+            star_pos = parse_state.pos
+            _ = rule_nextname(parse_state)
             if _ == ERROR:
-                compiler_state.pos = star_pos
+                parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
         last_variable = append_named_action(last_variable, 'xs', _)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, action_33, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, action_33, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_nextname(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_nextname(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '.'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        _ = rule_name(compiler_state)
+        _ = rule_name(parse_state)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_wvar(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_wvar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'W['
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        if compiler_state.pos != len(compiler_state.input_buffer):
-            compiler_state.pos += 1
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+        if parse_state.pos != len(parse_state.input_buffer):
+            parse_state.pos += 1
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
             data = ']'
-            if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-                compiler_state.pos += len(data)
-                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+                parse_state.pos += len(data)
+                _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(compiler_state.input_buffer, action_34, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(parse_state.input_buffer, action_34, pre_first_variable.next, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_stringinner(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_stringinner(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    nlookahead_pos = compiler_state.pos
-    _ = rule_stringend(compiler_state)
+    nlookahead_pos = parse_state.pos
+    _ = rule_stringend(parse_state)
     if _ == ERROR:
         _ = lambda: None
     else:
         _ = ERROR
-    compiler_state.pos = nlookahead_pos
+    parse_state.pos = nlookahead_pos
     if _ != ERROR:
-        if compiler_state.pos != len(compiler_state.input_buffer):
-            compiler_state.pos += 1
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+        if parse_state.pos != len(parse_state.input_buffer):
+            parse_state.pos += 1
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_stringend(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_stringend(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '"'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_charstring(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_charstring(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_quote(compiler_state)
+    _ = rule_quote(parse_state)
     if _ != ERROR:
         star_pre_first = Variable()
         star_last = star_pre_first
-        star_start_pos = compiler_state.pos
+        star_start_pos = parse_state.pos
         while True:
-            star_pos = compiler_state.pos
-            _ = rule_innercharstring(compiler_state)
+            star_pos = parse_state.pos
+            _ = rule_innercharstring(parse_state)
             if _ == ERROR:
-                compiler_state.pos = star_pos
+                parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
         if _ != ERROR:
-            _ = rule_quote(compiler_state)
+            _ = rule_quote(parse_state)
             if _ != ERROR:
-                return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+                return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_quote(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_quote(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '\''
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_innercharstring(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_innercharstring(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '\\\''
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, action_35, pre_first_variable.next, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, action_35, pre_first_variable.next, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    nlookahead_pos = compiler_state.pos
-    _ = rule_quote(compiler_state)
+    nlookahead_pos = parse_state.pos
+    _ = rule_quote(parse_state)
     if _ == ERROR:
         _ = lambda: None
     else:
         _ = ERROR
-    compiler_state.pos = nlookahead_pos
+    parse_state.pos = nlookahead_pos
     if _ != ERROR:
-        if compiler_state.pos != len(compiler_state.input_buffer):
-            compiler_state.pos += 1
-            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+        if parse_state.pos != len(parse_state.input_buffer):
+            parse_state.pos += 1
+            _ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_name(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_name(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    _ = rule_char(compiler_state)
+    _ = rule_char(parse_state)
     if _ != ERROR:
         star_pre_first = Variable()
         star_last = star_pre_first
-        star_start_pos = compiler_state.pos
+        star_start_pos = parse_state.pos
         while True:
-            star_pos = compiler_state.pos
-            _ = rule_char(compiler_state)
+            star_pos = parse_state.pos
+            _ = rule_char(parse_state)
             if _ == ERROR:
-                compiler_state.pos = star_pos
+                parse_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
         if _ != ERROR:
-            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_char(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_char(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'a'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'b'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'c'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'd'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'e'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'f'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'g'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'h'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'i'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'j'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'k'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'l'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'm'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'n'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'o'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'p'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'q'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'r'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 's'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 't'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'u'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'v'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'w'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'x'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'y'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'z'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'A'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'B'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'C'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'D'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'E'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'F'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'G'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'H'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'I'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'J'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'K'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'L'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'M'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'N'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'O'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'P'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'Q'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'R'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'S'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'T'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'U'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'V'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'W'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'X'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'Y'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = 'Z'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_space(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_space(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     star_pre_first = Variable()
     star_last = star_pre_first
-    star_start_pos = compiler_state.pos
+    star_start_pos = parse_state.pos
     while True:
-        star_pos = compiler_state.pos
-        _ = rule_spacechar(compiler_state)
+        star_pos = parse_state.pos
+        _ = rule_spacechar(parse_state)
         if _ == ERROR:
-            compiler_state.pos = star_pos
+            parse_state.pos = star_pos
             break
         star_last = append_named_action(star_last, None, _)
-    _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+    _ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
-def rule_spacechar(compiler_state):
-    or_backtrack_pos = compiler_state.pos
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+def rule_spacechar(parse_state):
+    or_backtrack_pos = parse_state.pos
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = ' '
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
-    compiler_state.pos = or_backtrack_pos
-    action_start_pos = compiler_state.pos
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
+    parse_state.pos = or_backtrack_pos
+    action_start_pos = parse_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     data = '\n'
-    if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
-        compiler_state.pos += len(data)
-        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+    if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:
+        parse_state.pos += len(data)
+        _ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)
     return ERROR
 
 if __name__ == '__main__':
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 758d247..343185a 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -140,14 +140,14 @@ file = rule*:xs space !. -> {
 };
 
 rule = space name:x space '=' space ors:y space ';' -> {
-    "def rule_" x "(compiler_state):\n" >
+    "def rule_" x "(parse_state):\n" >
         y
     <
     "\n"
 };
 
 ors = maybeorbar orcase:x restorcase*:xs -> {
-    "or_backtrack_pos = compiler_state.pos\n"
+    "or_backtrack_pos = parse_state.pos\n"
     x
     xs
     "return ERROR\n"
@@ -160,8 +160,8 @@ maybeorbar = orbar | -> {};
 orbar = space '|';
 
 orcase = matchAnd:x -> {
-    "compiler_state.pos = or_backtrack_pos\n"
-    "action_start_pos = compiler_state.pos\n"
+    "parse_state.pos = or_backtrack_pos\n"
+    "action_start_pos = parse_state.pos\n"
     "pre_first_variable = Variable()\n"
     "last_variable = pre_first_variable\n"
     x
@@ -179,7 +179,7 @@ matchAnd =
 
 matchExpr =
     | '!' matchExprPrimitive:x -> {
-        "nlookahead_pos = compiler_state.pos\n"
+        "nlookahead_pos = parse_state.pos\n"
         x
         "if _ == ERROR:\n" >
             "_ = lambda: None\n"
@@ -187,7 +187,7 @@ matchExpr =
         "else:\n" >
             "_ = ERROR\n"
         <
-        "compiler_state.pos = nlookahead_pos\n"
+        "parse_state.pos = nlookahead_pos\n"
     }
     | matchExprRepeat:x matchAssign:y -> { x y }
     ;
@@ -201,17 +201,17 @@ matchExprRepeat =
     | matchExprPrimitive:x '*' -> {
         "star_pre_first = Variable()\n"
         "star_last = star_pre_first\n"
-        "star_start_pos = compiler_state.pos\n"
+        "star_start_pos = parse_state.pos\n"
         "while True:\n" >
-            "star_pos = compiler_state.pos\n"
+            "star_pos = parse_state.pos\n"
             x
             "if _ == ERROR:\n" >
-                "compiler_state.pos = star_pos\n"
+                "parse_state.pos = star_pos\n"
                 "break\n"
             <
             "star_last = append_named_action(star_last, None, _)\n"
         <
-        "_ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n"
+        "_ = Action(parse_state.input_buffer, None, star_pre_first.next, star_start_pos, parse_state.pos)\n"
     }
     | matchExprPrimitive:x -> {
         x
@@ -220,12 +220,12 @@ matchExprRepeat =
 
 matchExprPrimitive =
     | name:x       -> {
-        "_ = rule_" x "(compiler_state)\n"
+        "_ = rule_" x "(parse_state)\n"
     }
     | '.'          -> {
-        "if compiler_state.pos != len(compiler_state.input_buffer):\n" >
-            "compiler_state.pos += 1\n"
-            "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n"
+        "if parse_state.pos != len(parse_state.input_buffer):\n" >
+            "parse_state.pos += 1\n"
+            "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-1, parse_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -233,9 +233,9 @@ matchExprPrimitive =
     }
     | charstring:x -> {
         "data = " x "\n"
-        "if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:\n" >
-            "compiler_state.pos += len(data)\n"
-            "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n"
+        "if parse_state.input_buffer[parse_state.pos:parse_state.pos+len(data)] == data:\n" >
+            "parse_state.pos += len(data)\n"
+            "_ = Action(parse_state.input_buffer, None, None, parse_state.pos-len(data), parse_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -253,10 +253,10 @@ action =
             <
             "\n"
         }
-        "return Action(compiler_state.input_buffer, action_" W[0] ", pre_first_variable.next, action_start_pos, compiler_state.pos)\n"
+        "return Action(parse_state.input_buffer, action_" W[0] ", pre_first_variable.next, action_start_pos, parse_state.pos)\n"
     }
     | -> {
-        "return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n"
+        "return Action(parse_state.input_buffer, None, None, action_start_pos, parse_state.pos)\n"
     }
     ;
 

commit ddf9f77b165483fd08a0813338e56ac5283923e2
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:48:10 2025 +0100

    Better name runtime

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 8c76d6c..ebf7c8d 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -39,17 +39,17 @@ class Variable:
         self.name = None
         self.action = None
 
-def run_action(action, state):
+def run_action(action, runtime):
     if action.function is None:
         if action.variable is None:
-            state.current_chunk_buffer.last = append_data(state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)
+            runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)
         else:
             variable = action.variable
             while variable:
-                run_action(variable.action, state)
+                run_action(variable.action, runtime)
                 variable = variable.next
     else:
-        action.function(state, action.variable)
+        action.function(runtime, action.variable)
 
 def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):
     next_chunk = Chunk()
@@ -96,457 +96,457 @@ def render_chunk_buffer(chunk_buffer, last_char='\n', indent=0):
 
 ERROR = -1
 
-def action_1(compiler_state, variable):
+def action_1(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'x'), compiler_state)
+    run_action(lookup_action(variable, 'x'), runtime)
 
-def action_2(compiler_state, variable):
+def action_2(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "import sys\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class CompilerState:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self, input_buffer):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.pos = 0\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.output_chunk_buffer = ChunkBuffer()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "import sys\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class CompilerState:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self, input_buffer):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.pos = 0\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.output_chunk_buffer = ChunkBuffer()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
     new_chunk_buffer = ChunkBuffer()
-    compiler_state.namedBuffers_chunk_buffer = new_chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.placeholders = []\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.W = {}\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Action:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self, input_buffer, function, variable, start, end):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.function = function\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.variable = variable\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.start = start\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.end = end\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.len = end-start\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class ChunkBuffer:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.pre_start = Chunk()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.last = self.pre_start\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Chunk:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.next = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.data = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.chunk_buffer = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.indentation_delta = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Variable:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.next = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.name = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.action = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def run_action(action, state):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if action.function is None:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if action.variable is None:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "state.current_chunk_buffer.last = append_data(state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "variable = action.variable\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "while variable:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(variable.action, state)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "variable = variable.next\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "action.function(state, action.variable)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_chunk = Chunk()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_chunk.next = chunk.next\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_chunk.data = data\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_chunk.chunk_buffer = sub_chunk_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_chunk.indentation_delta = indentation_delta\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "chunk.next = next_chunk\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return next_chunk\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def append_named_action(variable, name, action):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_variable = Variable()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_variable.next = variable.next\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_variable.name = name\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_variable.action = action\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "variable.next = next_variable\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return next_variable\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def lookup_action(variable, name_to_look_for):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "variable = variable\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "while variable:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if variable.name == name_to_look_for:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return variable.action\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "variable = variable.next\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def inc(value, amount):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return value + amount\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def render_chunk_buffer(chunk_buffer, last_char='\\n', indent=0):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if chunk_buffer:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "chunk = chunk_buffer.pre_start.next\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "while chunk:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "indent += chunk.indentation_delta\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "for char in chunk.data:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if last_char == '\\n':\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "sys.stdout.write('    '*indent)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_char = char\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "sys.stdout.write(last_char)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "chunk = chunk.next\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return last_char, indent\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "ERROR = -1\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
+    runtime.namedBuffers_chunk_buffer = new_chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.placeholders = []\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.W = {}\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Action:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self, input_buffer, function, variable, start, end):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.function = function\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.variable = variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.start = start\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.end = end\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.len = end-start\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class ChunkBuffer:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.pre_start = Chunk()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.last = self.pre_start\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Chunk:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.next = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.data = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.chunk_buffer = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.indentation_delta = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "class Variable:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def __init__(self):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.next = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.name = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.action = None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def run_action(action, runtime):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if action.function is None:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if action.variable is None:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = action.variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while variable:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(variable.action, runtime)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = variable.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "action.function(runtime, action.variable)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk = Chunk()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.next = chunk.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.data = data\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.chunk_buffer = sub_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_chunk.indentation_delta = indentation_delta\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk.next = next_chunk\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return next_chunk\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def append_named_action(variable, name, action):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable = Variable()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable.next = variable.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable.name = name\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "next_variable.action = action\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable.next = next_variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return next_variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def lookup_action(variable, name_to_look_for):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = variable\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while variable:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if variable.name == name_to_look_for:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return variable.action\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "variable = variable.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "raise ValueError(f'variable {name_to_look_for} not found')\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def inc(value, amount):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return value + amount\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def render_chunk_buffer(chunk_buffer, last_char='\\n', indent=0):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if chunk_buffer:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk = chunk_buffer.pre_start.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while chunk:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "indent += chunk.indentation_delta\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "for char in chunk.data:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if last_char == '\\n':\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "sys.stdout.write('    '*indent)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_char = char\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "sys.stdout.write(last_char)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_char, indent = render_chunk_buffer(chunk.chunk_buffer, last_char, indent)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk = chunk.next\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return last_char, indent\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "ERROR = -1\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
     new_chunk_buffer = ChunkBuffer()
-    compiler_state.action_chunk_buffer = new_chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)
+    runtime.action_chunk_buffer = new_chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)
     new_chunk_buffer = ChunkBuffer()
-    compiler_state.placeholder_chunk_buffer = new_chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)
-    run_action(lookup_action(variable, 'xs'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if __name__ == '__main__':\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state = CompilerState(sys.stdin.read())\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(rule_main(compiler_state), compiler_state)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "for chunk_buffer, action in compiler_state.placeholders:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = chunk_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(action, compiler_state)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "render_chunk_buffer(compiler_state.output_chunk_buffer)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-
-def action_3(compiler_state, variable):
+    runtime.placeholder_chunk_buffer = new_chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)
+    run_action(lookup_action(variable, 'xs'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if __name__ == '__main__':\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state = CompilerState(sys.stdin.read())\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(rule_main(compiler_state), compiler_state)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "for chunk_buffer, action in compiler_state.placeholders:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(action, compiler_state)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "render_chunk_buffer(compiler_state.output_chunk_buffer)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+
+def action_3(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def rule_", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    run_action(lookup_action(variable, 'y'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-
-def action_4(compiler_state, variable):
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def rule_", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(compiler_state):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    run_action(lookup_action(variable, 'y'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+
+def action_4(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "or_backtrack_pos = compiler_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    run_action(lookup_action(variable, 'xs'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "or_backtrack_pos = compiler_state.pos\n", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variable, 'xs'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return ERROR\n", 0)
 
-def action_5(compiler_state, variable):
+def action_5(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'x'), compiler_state)
+    run_action(lookup_action(variable, 'x'), runtime)
 
-def action_6(compiler_state, variable):
+def action_6(runtime, variable):
     pass
 
-def action_7(compiler_state, variable):
+def action_7(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos = or_backtrack_pos\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "action_start_pos = compiler_state.pos\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "pre_first_variable = Variable()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_variable = pre_first_variable\n", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos = or_backtrack_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "action_start_pos = compiler_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "pre_first_variable = Variable()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_variable = pre_first_variable\n", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
 
-def action_8(compiler_state, variable):
+def action_8(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if _ != ERROR:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    run_action(lookup_action(variable, 'y'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ != ERROR:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    run_action(lookup_action(variable, 'y'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
 
-def action_9(compiler_state, variable):
+def action_9(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'y'), compiler_state)
+    run_action(lookup_action(variable, 'y'), runtime)
 
-def action_10(compiler_state, variable):
+def action_10(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "nlookahead_pos = compiler_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = lambda: None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = ERROR\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos = nlookahead_pos\n", 0)
-
-def action_11(compiler_state, variable):
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "nlookahead_pos = compiler_state.pos\n", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = lambda: None\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos = nlookahead_pos\n", 0)
+
+def action_11(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    run_action(lookup_action(variable, 'y'), compiler_state)
+    run_action(lookup_action(variable, 'x'), runtime)
+    run_action(lookup_action(variable, 'y'), runtime)
 
-def action_12(compiler_state, variable):
+def action_12(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_variable = append_named_action(last_variable, '", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "', _)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_variable = append_named_action(last_variable, '", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "', _)\n", 0)
 
-def action_13(compiler_state, variable):
+def action_13(runtime, variable):
     pass
 
-def action_14(compiler_state, variable):
+def action_14(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "star_pre_first = Variable()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "star_last = star_pre_first\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "star_start_pos = compiler_state.pos\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "while True:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "star_pos = compiler_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos = star_pos\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "break\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "star_last = append_named_action(star_last, None, _)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n", 0)
-
-def action_15(compiler_state, variable):
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_pre_first = Variable()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_last = star_pre_first\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_start_pos = compiler_state.pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "while True:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_pos = compiler_state.pos\n", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos = star_pos\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "break\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "star_last = append_named_action(star_last, None, _)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n", 0)
+
+def action_15(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'x'), compiler_state)
+    run_action(lookup_action(variable, 'x'), runtime)
 
-def action_16(compiler_state, variable):
+def action_16(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = rule_", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = rule_", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(compiler_state)\n", 0)
 
-def action_17(compiler_state, variable):
+def action_17(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if compiler_state.pos != len(compiler_state.input_buffer):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos += 1\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = ERROR\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-
-def action_18(compiler_state, variable):
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if compiler_state.pos != len(compiler_state.input_buffer):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos += 1\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+
+def action_18(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "data = ", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos += len(data)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = ERROR\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-
-def action_19(compiler_state, variable):
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "data = ", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "compiler_state.pos += len(data)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "else:\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_ = ERROR\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+
+def action_19(runtime, variable):
     pass
-    compiler_state.W[0] = inc(compiler_state.W.get(0, 0), 1)
-    last_chunk_buffer = compiler_state.current_chunk_buffer
-    chunk_buffer = compiler_state.action_chunk_buffer
-    compiler_state.current_chunk_buffer = chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def action_", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(compiler_state.W.get(0, 0)), 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state, variable):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "pass\n", 0)
-    run_action(lookup_action(variable, 'xs'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer = last_chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, action_", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(compiler_state.W.get(0, 0)), 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", pre_first_variable.next, action_start_pos, compiler_state.pos)\n", 0)
-
-def action_20(compiler_state, variable):
+    runtime.W[0] = inc(runtime.W.get(0, 0), 1)
+    last_chunk_buffer = runtime.current_chunk_buffer
+    chunk_buffer = runtime.action_chunk_buffer
+    runtime.current_chunk_buffer = chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def action_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime, variable):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "pass\n", 0)
+    run_action(lookup_action(variable, 'xs'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer = last_chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, action_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(0, 0)), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", pre_first_variable.next, action_start_pos, compiler_state.pos)\n", 0)
+
+def action_20(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n", 0)
 
-def action_21(compiler_state, variable):
+def action_21(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_chunk_buffer = compiler_state.current_chunk_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "chunk_buffer = compiler_state.", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_chunk_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = chunk_buffer\n", 0)
-    run_action(lookup_action(variable, 'ys'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = last_chunk_buffer\n", 0)
-    last_chunk_buffer = compiler_state.current_chunk_buffer
-    chunk_buffer = compiler_state.namedBuffers_chunk_buffer
-    compiler_state.current_chunk_buffer = chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_chunk_buffer = None\n", 0)
-    compiler_state.current_chunk_buffer = last_chunk_buffer
-
-def action_22(compiler_state, variable):
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "last_chunk_buffer = runtime.current_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "chunk_buffer = runtime.", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer = chunk_buffer\n", 0)
+    run_action(lookup_action(variable, 'ys'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer = last_chunk_buffer\n", 0)
+    last_chunk_buffer = runtime.current_chunk_buffer
+    chunk_buffer = runtime.namedBuffers_chunk_buffer
+    runtime.current_chunk_buffer = chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "self.", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_chunk_buffer = None\n", 0)
+    runtime.current_chunk_buffer = last_chunk_buffer
+
+def action_22(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_chunk_buffer = new_chunk_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "_chunk_buffer = new_chunk_buffer\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
 
-def action_23(compiler_state, variable):
+def action_23(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "), 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "), 0)\n", 0)
 
-def action_24(compiler_state, variable):
+def action_24(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(lookup_action(variable, '", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "'), compiler_state)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "run_action(lookup_action(variable, '", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "'), runtime)\n", 0)
 
-def action_25(compiler_state, variable):
+def action_25(runtime, variable):
     pass
-    compiler_state.W[1] = inc(compiler_state.W.get(1, 0), 1)
-    last_chunk_buffer = compiler_state.current_chunk_buffer
-    chunk_buffer = compiler_state.placeholder_chunk_buffer
-    compiler_state.current_chunk_buffer = chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def placeholder_", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(compiler_state.W.get(1, 0)), 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state, variable):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "pass\n", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer = last_chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.placeholders.append((new_chunk_buffer, Action(compiler_state.input_buffer, placeholder_", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(compiler_state.W.get(1, 0)), 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", variable, 0, 0)))\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
-
-def action_26(compiler_state, variable):
+    runtime.W[1] = inc(runtime.W.get(1, 0), 1)
+    last_chunk_buffer = runtime.current_chunk_buffer
+    chunk_buffer = runtime.placeholder_chunk_buffer
+    runtime.current_chunk_buffer = chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "def placeholder_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime, variable):\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "pass\n", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "\n", 0)
+    runtime.current_chunk_buffer = last_chunk_buffer
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.placeholders.append((new_chunk_buffer, Action('', placeholder_", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(runtime.W.get(1, 0)), 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", variable, 0, 0)))\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
+
+def action_26(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)\n", 0)
 
-def action_27(compiler_state, variable):
+def action_27(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.W[", 0)
-    run_action(lookup_action(variable, 'y'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "] = ", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state.W.get(", 0)
-    run_action(lookup_action(variable, 'y'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0), ", 0)
-    run_action(lookup_action(variable, 'z'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ")\n", 0)
-
-def action_28(compiler_state, variable):
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.W[", 0)
+    run_action(lookup_action(variable, 'y'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "] = ", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime.W.get(", 0)
+    run_action(lookup_action(variable, 'y'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0), ", 0)
+    run_action(lookup_action(variable, 'z'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ")\n", 0)
+
+def action_28(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)\n", 0)
-    run_action(lookup_action(variable, 'xs'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)\n", 0)
+    run_action(lookup_action(variable, 'xs'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)\n", 0)
 
-def action_29(compiler_state, variable):
+def action_29(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'x'), compiler_state)
+    run_action(lookup_action(variable, 'x'), runtime)
 
-def action_30(compiler_state, variable):
+def action_30(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "*", 0)
-    run_action(lookup_action(variable, 'y'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)\n", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "*", 0)
+    run_action(lookup_action(variable, 'y'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)\n", 0)
 
-def action_31(compiler_state, variable):
+def action_31(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.W.get(", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "runtime.W.get(", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)", 0)
 
-def action_32(compiler_state, variable):
+def action_32(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state.W.get(", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)-", 0)
-    run_action(lookup_action(variable, 'y'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ")", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "(runtime.W.get(", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ", 0)-", 0)
+    run_action(lookup_action(variable, 'y'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, ")", 0)
 
-def action_33(compiler_state, variable):
+def action_33(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "lookup_action(variable, '", 0)
-    run_action(lookup_action(variable, 'x'), compiler_state)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "')", 0)
-    run_action(lookup_action(variable, 'xs'), compiler_state)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "lookup_action(variable, '", 0)
+    run_action(lookup_action(variable, 'x'), runtime)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "')", 0)
+    run_action(lookup_action(variable, 'xs'), runtime)
 
-def action_34(compiler_state, variable):
+def action_34(runtime, variable):
     pass
-    run_action(lookup_action(variable, 'x'), compiler_state)
+    run_action(lookup_action(variable, 'x'), runtime)
 
-def action_35(compiler_state, variable):
+def action_35(runtime, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "'", 0)
+    runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, "'", 0)
 
 def rule_main(compiler_state):
     or_backtrack_pos = compiler_state.pos
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index fc4faec..758d247 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -50,21 +50,21 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
-    "def run_action(action, state):\n" >
+    "def run_action(action, runtime):\n" >
         "if action.function is None:\n" >
             "if action.variable is None:\n" >
-                "state.current_chunk_buffer.last = append_data(state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n"
+                "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n"
             <
             "else:\n" >
                 "variable = action.variable\n"
                 "while variable:\n" >
-                    "run_action(variable.action, state)\n"
+                    "run_action(variable.action, runtime)\n"
                     "variable = variable.next\n"
                 <
             <
         <
         "else:\n" >
-            "action.function(state, action.variable)\n"
+            "action.function(runtime, action.variable)\n"
         <
     <
     "\n"
@@ -247,7 +247,7 @@ action =
     | space '->' space '{' actionexpr*:xs space '}' -> {
         #inc(W[0] 1)
         >action {
-            "def action_" W[0] "(compiler_state, variable):\n" >
+            "def action_" W[0] "(runtime, variable):\n" >
                 "pass\n"
                 xs
             <
@@ -262,49 +262,49 @@ action =
 
 actionexpr =
     | space '>' name:x space '{' actionexpr*:ys space '}' -> {
-        "last_chunk_buffer = compiler_state.current_chunk_buffer\n"
-        "chunk_buffer = compiler_state." x "_chunk_buffer\n"
-        "compiler_state.current_chunk_buffer = chunk_buffer\n"
+        "last_chunk_buffer = runtime.current_chunk_buffer\n"
+        "chunk_buffer = runtime." x "_chunk_buffer\n"
+        "runtime.current_chunk_buffer = chunk_buffer\n"
         ys
-        "compiler_state.current_chunk_buffer = last_chunk_buffer\n"
+        "runtime.current_chunk_buffer = last_chunk_buffer\n"
         >namedBuffers {
             "self." x "_chunk_buffer = None\n"
         }
     }
     | space '<' name:x -> {
         "new_chunk_buffer = ChunkBuffer()\n"
-        "compiler_state." x "_chunk_buffer = new_chunk_buffer\n"
-        "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
+        "runtime." x "_chunk_buffer = new_chunk_buffer\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
     }
     | space expr:x -> {
-        "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(" x "), 0)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, str(" x "), 0)\n"
     }
     | space name:x -> {
-        "run_action(lookup_action(variable, '" x "'), compiler_state)\n"
+        "run_action(lookup_action(variable, '" x "'), runtime)\n"
     }
     | space placeholder:x -> {
         #inc(W[1] 1)
         >placeholder {
-            "def placeholder_" W[1] "(compiler_state, variable):\n" >
+            "def placeholder_" W[1] "(runtime, variable):\n" >
                 "pass\n"
                 x
             <
             "\n"
         }
         "new_chunk_buffer = ChunkBuffer()\n"
-        "compiler_state.placeholders.append((new_chunk_buffer, Action(compiler_state.input_buffer, placeholder_" W[1] ", variable, 0, 0)))\n"
-        "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
+        "runtime.placeholders.append((new_chunk_buffer, Action('', placeholder_" W[1] ", variable, 0, 0)))\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
     }
     | space string:x -> {
-        "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, " x ", 0)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, " x ", 0)\n"
     }
     | space '#' name:x '(' wvar:y ' ' actionPrimitiveExpression:z ')' -> {
-        "compiler_state.W[" y "] = " x "(compiler_state.W.get(" y ", 0), " z ")\n"
+        "runtime.W[" y "] = " x "(runtime.W.get(" y ", 0), " z ")\n"
     }
     | space '>' actionexpr*:xs space '<' -> {
-        "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', 1)\n"
         xs
-        "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, '', -1)\n"
     }
     ;
 
@@ -328,16 +328,16 @@ digit =
 
 placeholder
     = '{' space string:x '*' expr:y space '}' -> {
-        "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, " x "*" y ", 0)\n"
+        "runtime.current_chunk_buffer.last = append_data(runtime.current_chunk_buffer.last, " x "*" y ", 0)\n"
     }
     ;
 
 expr =
     | wvar:x -> {
-        "compiler_state.W.get(" x ", 0)"
+        "runtime.W.get(" x ", 0)"
     }
     | '(' wvar:x '-' dotname:y ')' -> {
-        "(compiler_state.W.get(" x ", 0)-"  y ")"
+        "(runtime.W.get(" x ", 0)-"  y ")"
     }
     ;
 

commit 51299be6dc9fda5403dcdb8b2638830923a4c070
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:42:17 2025 +0100

    Actions should not store the compiler state

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 9bfe872..8c76d6c 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -13,8 +13,7 @@ class CompilerState:
         self.W = {}
 
 class Action:
-    def __init__(self, compiler_state, input_buffer, function, variable, start, end):
-        self.compiler_state = compiler_state
+    def __init__(self, input_buffer, function, variable, start, end):
         self.function = function
         self.variable = variable
         self.input_buffer = input_buffer
@@ -40,17 +39,17 @@ class Variable:
         self.name = None
         self.action = None
 
-def run_action(action):
+def run_action(action, state):
     if action.function is None:
         if action.variable is None:
-            action.compiler_state.current_chunk_buffer.last = append_data(action.compiler_state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)
+            state.current_chunk_buffer.last = append_data(state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)
         else:
             variable = action.variable
             while variable:
-                run_action(variable.action)
+                run_action(variable.action, state)
                 variable = variable.next
     else:
-        action.function(action.compiler_state, action.variable)
+        action.function(state, action.variable)
 
 def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):
     next_chunk = Chunk()
@@ -99,7 +98,7 @@ ERROR = -1
 
 def action_1(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
 
 def action_2(compiler_state, variable):
     pass
@@ -123,9 +122,8 @@ def action_2(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Action:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self, compiler_state, input_buffer, function, variable, start, end):\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self, input_buffer, function, variable, start, end):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.compiler_state = compiler_state\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.function = function\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.variable = variable\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.input_buffer = input_buffer\n", 0)
@@ -165,27 +163,27 @@ def action_2(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def run_action(action):\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def run_action(action, state):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if action.function is None:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if action.variable is None:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "action.compiler_state.current_chunk_buffer.last = append_data(action.compiler_state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "state.current_chunk_buffer.last = append_data(state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "variable = action.variable\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "while variable:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(variable.action)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(variable.action, state)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "variable = variable.next\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "action.function(action.compiler_state, action.variable)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "action.function(state, action.variable)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
@@ -264,15 +262,15 @@ def action_2(compiler_state, variable):
     new_chunk_buffer = ChunkBuffer()
     compiler_state.placeholder_chunk_buffer = new_chunk_buffer
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)
-    run_action(lookup_action(variable, 'xs'))
+    run_action(lookup_action(variable, 'xs'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if __name__ == '__main__':\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state = CompilerState(sys.stdin.read())\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(rule_main(compiler_state))\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(rule_main(compiler_state), compiler_state)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "for chunk_buffer, action in compiler_state.placeholders:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = chunk_buffer\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(action)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(action, compiler_state)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "render_chunk_buffer(compiler_state.output_chunk_buffer)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
@@ -280,23 +278,23 @@ def action_2(compiler_state, variable):
 def action_3(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def rule_", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'y'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
 
 def action_4(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "or_backtrack_pos = compiler_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'))
-    run_action(lookup_action(variable, 'xs'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
+    run_action(lookup_action(variable, 'xs'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return ERROR\n", 0)
 
 def action_5(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
 
 def action_6(compiler_state, variable):
     pass
@@ -307,24 +305,24 @@ def action_7(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "action_start_pos = compiler_state.pos\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "pre_first_variable = Variable()\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_variable = pre_first_variable\n", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
 
 def action_8(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if _ != ERROR:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'y'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
 
 def action_9(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'y'), compiler_state)
 
 def action_10(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "nlookahead_pos = compiler_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = lambda: None\n", 0)
@@ -337,13 +335,13 @@ def action_10(compiler_state, variable):
 
 def action_11(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'x'))
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
+    run_action(lookup_action(variable, 'y'), compiler_state)
 
 def action_12(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_variable = append_named_action(last_variable, '", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "', _)\n", 0)
 
 def action_13(compiler_state, variable):
@@ -357,7 +355,7 @@ def action_14(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "while True:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "star_pos = compiler_state.pos\n", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if _ == ERROR:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos = star_pos\n", 0)
@@ -365,16 +363,16 @@ def action_14(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "star_last = append_named_action(star_last, None, _)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n", 0)
 
 def action_15(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
 
 def action_16(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = rule_", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state)\n", 0)
 
 def action_17(compiler_state, variable):
@@ -382,7 +380,7 @@ def action_17(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if compiler_state.pos != len(compiler_state.input_buffer):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos += 1\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
@@ -392,12 +390,12 @@ def action_17(compiler_state, variable):
 def action_18(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "data = ", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.pos += len(data)\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "else:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
@@ -415,32 +413,32 @@ def action_19(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state, variable):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "pass\n", 0)
-    run_action(lookup_action(variable, 'xs'))
+    run_action(lookup_action(variable, 'xs'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer = last_chunk_buffer
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return Action(compiler_state, compiler_state.input_buffer, action_", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, action_", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(compiler_state.W.get(0, 0)), 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", pre_first_variable.next, action_start_pos, compiler_state.pos)\n", 0)
 
 def action_20(compiler_state, variable):
     pass
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n", 0)
 
 def action_21(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "last_chunk_buffer = compiler_state.current_chunk_buffer\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "chunk_buffer = compiler_state.", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_chunk_buffer\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = chunk_buffer\n", 0)
-    run_action(lookup_action(variable, 'ys'))
+    run_action(lookup_action(variable, 'ys'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = last_chunk_buffer\n", 0)
     last_chunk_buffer = compiler_state.current_chunk_buffer
     chunk_buffer = compiler_state.namedBuffers_chunk_buffer
     compiler_state.current_chunk_buffer = chunk_buffer
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_chunk_buffer = None\n", 0)
     compiler_state.current_chunk_buffer = last_chunk_buffer
 
@@ -448,21 +446,21 @@ def action_22(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_chunk_buffer = new_chunk_buffer\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
 
 def action_23(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "), 0)\n", 0)
 
 def action_24(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "run_action(lookup_action(variable, '", 0)
-    run_action(lookup_action(variable, 'x'))
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "'))\n", 0)
+    run_action(lookup_action(variable, 'x'), compiler_state)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "'), compiler_state)\n", 0)
 
 def action_25(compiler_state, variable):
     pass
@@ -475,12 +473,12 @@ def action_25(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state, variable):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "pass\n", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer = last_chunk_buffer
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "new_chunk_buffer = ChunkBuffer()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.placeholders.append((new_chunk_buffer, Action(compiler_state, compiler_state.input_buffer, placeholder_", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.placeholders.append((new_chunk_buffer, Action(compiler_state.input_buffer, placeholder_", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(compiler_state.W.get(1, 0)), 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", variable, 0, 0)))\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n", 0)
@@ -488,63 +486,63 @@ def action_25(compiler_state, variable):
 def action_26(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)\n", 0)
 
 def action_27(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.W[", 0)
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'y'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "] = ", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state.W.get(", 0)
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'y'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0), ", 0)
-    run_action(lookup_action(variable, 'z'))
+    run_action(lookup_action(variable, 'z'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ")\n", 0)
 
 def action_28(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)\n", 0)
-    run_action(lookup_action(variable, 'xs'))
+    run_action(lookup_action(variable, 'xs'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)\n", 0)
 
 def action_29(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
 
 def action_30(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "*", 0)
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'y'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)\n", 0)
 
 def action_31(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.W.get(", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)", 0)
 
 def action_32(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "(compiler_state.W.get(", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ", 0)-", 0)
-    run_action(lookup_action(variable, 'y'))
+    run_action(lookup_action(variable, 'y'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, ")", 0)
 
 def action_33(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "lookup_action(variable, '", 0)
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "')", 0)
-    run_action(lookup_action(variable, 'xs'))
+    run_action(lookup_action(variable, 'xs'), compiler_state)
 
 def action_34(compiler_state, variable):
     pass
-    run_action(lookup_action(variable, 'x'))
+    run_action(lookup_action(variable, 'x'), compiler_state)
 
 def action_35(compiler_state, variable):
     pass
@@ -559,7 +557,7 @@ def rule_main(compiler_state):
     _ = rule_file(compiler_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_1, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_1, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_file(compiler_state):
@@ -578,7 +576,7 @@ def rule_file(compiler_state):
             compiler_state.pos = star_pos
             break
         star_last = append_named_action(star_last, None, _)
-    _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+    _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
     last_variable = append_named_action(last_variable, 'xs', _)
     if _ != ERROR:
         _ = rule_space(compiler_state)
@@ -586,7 +584,7 @@ def rule_file(compiler_state):
             nlookahead_pos = compiler_state.pos
             if compiler_state.pos != len(compiler_state.input_buffer):
                 compiler_state.pos += 1
-                _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
             else:
                 _ = ERROR
             if _ == ERROR:
@@ -595,7 +593,7 @@ def rule_file(compiler_state):
                 _ = ERROR
             compiler_state.pos = nlookahead_pos
             if _ != ERROR:
-                return Action(compiler_state, compiler_state.input_buffer, action_2, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(compiler_state.input_buffer, action_2, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_rule(compiler_state):
@@ -614,7 +612,7 @@ def rule_rule(compiler_state):
                 data = '='
                 if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                     compiler_state.pos += len(data)
-                    _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -628,11 +626,11 @@ def rule_rule(compiler_state):
                                 data = ';'
                                 if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                                     compiler_state.pos += len(data)
-                                    _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(compiler_state, compiler_state.input_buffer, action_3, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                                    return Action(compiler_state.input_buffer, action_3, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_ors(compiler_state):
@@ -656,10 +654,10 @@ def rule_ors(compiler_state):
                     compiler_state.pos = star_pos
                     break
                 star_last = append_named_action(star_last, None, _)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
-                return Action(compiler_state, compiler_state.input_buffer, action_4, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(compiler_state.input_buffer, action_4, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_restorcase(compiler_state):
@@ -673,7 +671,7 @@ def rule_restorcase(compiler_state):
         _ = rule_orcase(compiler_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_5, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_5, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_maybeorbar(compiler_state):
@@ -684,12 +682,12 @@ def rule_maybeorbar(compiler_state):
     last_variable = pre_first_variable
     _ = rule_orbar(compiler_state)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(compiler_state, compiler_state.input_buffer, action_6, pre_first_variable.next, action_start_pos, compiler_state.pos)
+    return Action(compiler_state.input_buffer, action_6, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_orbar(compiler_state):
@@ -703,11 +701,11 @@ def rule_orbar(compiler_state):
         data = '|'
         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
             compiler_state.pos += len(data)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_orcase(compiler_state):
@@ -719,7 +717,7 @@ def rule_orcase(compiler_state):
     _ = rule_matchAnd(compiler_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_7, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_7, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_matchAnd(compiler_state):
@@ -736,7 +734,7 @@ def rule_matchAnd(compiler_state):
             _ = rule_matchAnd(compiler_state)
             last_variable = append_named_action(last_variable, 'y', _)
             if _ != ERROR:
-                return Action(compiler_state, compiler_state.input_buffer, action_8, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(compiler_state.input_buffer, action_8, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -744,7 +742,7 @@ def rule_matchAnd(compiler_state):
     _ = rule_action(compiler_state)
     last_variable = append_named_action(last_variable, 'y', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_9, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_9, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_matchExpr(compiler_state):
@@ -756,14 +754,14 @@ def rule_matchExpr(compiler_state):
     data = '!'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_matchExprPrimitive(compiler_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_10, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_10, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -774,7 +772,7 @@ def rule_matchExpr(compiler_state):
         _ = rule_matchAssign(compiler_state)
         last_variable = append_named_action(last_variable, 'y', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_11, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_11, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_matchAssign(compiler_state):
@@ -786,19 +784,19 @@ def rule_matchAssign(compiler_state):
     data = ':'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_name(compiler_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_12, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_12, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(compiler_state, compiler_state.input_buffer, action_13, pre_first_variable.next, action_start_pos, compiler_state.pos)
+    return Action(compiler_state.input_buffer, action_13, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_matchExprRepeat(compiler_state):
@@ -813,11 +811,11 @@ def rule_matchExprRepeat(compiler_state):
         data = '*'
         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
             compiler_state.pos += len(data)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_14, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_14, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -825,7 +823,7 @@ def rule_matchExprRepeat(compiler_state):
     _ = rule_matchExprPrimitive(compiler_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_15, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_15, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_matchExprPrimitive(compiler_state):
@@ -837,7 +835,7 @@ def rule_matchExprPrimitive(compiler_state):
     _ = rule_name(compiler_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_16, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_16, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -845,11 +843,11 @@ def rule_matchExprPrimitive(compiler_state):
     data = '.'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_17, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_17, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -857,7 +855,7 @@ def rule_matchExprPrimitive(compiler_state):
     _ = rule_charstring(compiler_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_18, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_18, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_action(compiler_state):
@@ -871,7 +869,7 @@ def rule_action(compiler_state):
         data = '->'
         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
             compiler_state.pos += len(data)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -880,7 +878,7 @@ def rule_action(compiler_state):
                 data = '{'
                 if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                     compiler_state.pos += len(data)
-                    _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -894,7 +892,7 @@ def rule_action(compiler_state):
                             compiler_state.pos = star_pos
                             break
                         star_last = append_named_action(star_last, None, _)
-                    _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+                    _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
                     last_variable = append_named_action(last_variable, 'xs', _)
                     if _ != ERROR:
                         _ = rule_space(compiler_state)
@@ -902,16 +900,16 @@ def rule_action(compiler_state):
                             data = '}'
                             if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                                 compiler_state.pos += len(data)
-                                _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(compiler_state, compiler_state.input_buffer, action_19, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                                return Action(compiler_state.input_buffer, action_19, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
-    return Action(compiler_state, compiler_state.input_buffer, action_20, pre_first_variable.next, action_start_pos, compiler_state.pos)
+    return Action(compiler_state.input_buffer, action_20, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_actionexpr(compiler_state):
@@ -925,7 +923,7 @@ def rule_actionexpr(compiler_state):
         data = '>'
         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
             compiler_state.pos += len(data)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -937,7 +935,7 @@ def rule_actionexpr(compiler_state):
                     data = '{'
                     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                         compiler_state.pos += len(data)
-                        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
@@ -951,7 +949,7 @@ def rule_actionexpr(compiler_state):
                                 compiler_state.pos = star_pos
                                 break
                             star_last = append_named_action(star_last, None, _)
-                        _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+                        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
                         last_variable = append_named_action(last_variable, 'ys', _)
                         if _ != ERROR:
                             _ = rule_space(compiler_state)
@@ -959,11 +957,11 @@ def rule_actionexpr(compiler_state):
                                 data = '}'
                                 if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                                     compiler_state.pos += len(data)
-                                    _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(compiler_state, compiler_state.input_buffer, action_21, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                                    return Action(compiler_state.input_buffer, action_21, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -973,14 +971,14 @@ def rule_actionexpr(compiler_state):
         data = '<'
         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
             compiler_state.pos += len(data)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
             _ = rule_name(compiler_state)
             last_variable = append_named_action(last_variable, 'x', _)
             if _ != ERROR:
-                return Action(compiler_state, compiler_state.input_buffer, action_22, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(compiler_state.input_buffer, action_22, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -990,7 +988,7 @@ def rule_actionexpr(compiler_state):
         _ = rule_expr(compiler_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_23, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_23, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1000,7 +998,7 @@ def rule_actionexpr(compiler_state):
         _ = rule_name(compiler_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_24, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_24, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1010,7 +1008,7 @@ def rule_actionexpr(compiler_state):
         _ = rule_placeholder(compiler_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_25, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_25, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1020,7 +1018,7 @@ def rule_actionexpr(compiler_state):
         _ = rule_string(compiler_state)
         last_variable = append_named_action(last_variable, 'x', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_26, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_26, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1030,7 +1028,7 @@ def rule_actionexpr(compiler_state):
         data = '#'
         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
             compiler_state.pos += len(data)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -1040,7 +1038,7 @@ def rule_actionexpr(compiler_state):
                 data = '('
                 if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                     compiler_state.pos += len(data)
-                    _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -1050,7 +1048,7 @@ def rule_actionexpr(compiler_state):
                         data = ' '
                         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                             compiler_state.pos += len(data)
-                            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                         else:
                             _ = ERROR
                         if _ != ERROR:
@@ -1060,11 +1058,11 @@ def rule_actionexpr(compiler_state):
                                 data = ')'
                                 if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                                     compiler_state.pos += len(data)
-                                    _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                                 else:
                                     _ = ERROR
                                 if _ != ERROR:
-                                    return Action(compiler_state, compiler_state.input_buffer, action_27, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                                    return Action(compiler_state.input_buffer, action_27, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1074,7 +1072,7 @@ def rule_actionexpr(compiler_state):
         data = '>'
         if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
             compiler_state.pos += len(data)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
@@ -1088,7 +1086,7 @@ def rule_actionexpr(compiler_state):
                     compiler_state.pos = star_pos
                     break
                 star_last = append_named_action(star_last, None, _)
-            _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
             last_variable = append_named_action(last_variable, 'xs', _)
             if _ != ERROR:
                 _ = rule_space(compiler_state)
@@ -1096,11 +1094,11 @@ def rule_actionexpr(compiler_state):
                     data = '<'
                     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                         compiler_state.pos += len(data)
-                        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(compiler_state, compiler_state.input_buffer, action_28, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                        return Action(compiler_state.input_buffer, action_28, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_actionPrimitiveExpression(compiler_state):
@@ -1112,14 +1110,14 @@ def rule_actionPrimitiveExpression(compiler_state):
     _ = rule_dotname(compiler_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_29, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_29, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
     last_variable = pre_first_variable
     _ = rule_digit(compiler_state)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_digit(compiler_state):
@@ -1131,11 +1129,11 @@ def rule_digit(compiler_state):
     data = '0'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1143,11 +1141,11 @@ def rule_digit(compiler_state):
     data = '1'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1155,11 +1153,11 @@ def rule_digit(compiler_state):
     data = '2'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1167,11 +1165,11 @@ def rule_digit(compiler_state):
     data = '3'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1179,11 +1177,11 @@ def rule_digit(compiler_state):
     data = '4'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1191,11 +1189,11 @@ def rule_digit(compiler_state):
     data = '5'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1203,11 +1201,11 @@ def rule_digit(compiler_state):
     data = '6'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1215,11 +1213,11 @@ def rule_digit(compiler_state):
     data = '7'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1227,11 +1225,11 @@ def rule_digit(compiler_state):
     data = '8'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1239,11 +1237,11 @@ def rule_digit(compiler_state):
     data = '9'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_placeholder(compiler_state):
@@ -1255,7 +1253,7 @@ def rule_placeholder(compiler_state):
     data = '{'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1267,7 +1265,7 @@ def rule_placeholder(compiler_state):
                 data = '*'
                 if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                     compiler_state.pos += len(data)
-                    _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                    _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                 else:
                     _ = ERROR
                 if _ != ERROR:
@@ -1279,11 +1277,11 @@ def rule_placeholder(compiler_state):
                             data = '}'
                             if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                                 compiler_state.pos += len(data)
-                                _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                             else:
                                 _ = ERROR
                             if _ != ERROR:
-                                return Action(compiler_state, compiler_state.input_buffer, action_30, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                                return Action(compiler_state.input_buffer, action_30, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_expr(compiler_state):
@@ -1295,7 +1293,7 @@ def rule_expr(compiler_state):
     _ = rule_wvar(compiler_state)
     last_variable = append_named_action(last_variable, 'x', _)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_31, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_31, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1303,7 +1301,7 @@ def rule_expr(compiler_state):
     data = '('
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1313,7 +1311,7 @@ def rule_expr(compiler_state):
             data = '-'
             if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                 compiler_state.pos += len(data)
-                _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
@@ -1323,11 +1321,11 @@ def rule_expr(compiler_state):
                     data = ')'
                     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                         compiler_state.pos += len(data)
-                        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
                     else:
                         _ = ERROR
                     if _ != ERROR:
-                        return Action(compiler_state, compiler_state.input_buffer, action_32, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                        return Action(compiler_state.input_buffer, action_32, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_string(compiler_state):
@@ -1339,7 +1337,7 @@ def rule_string(compiler_state):
     data = '"'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
@@ -1353,16 +1351,16 @@ def rule_string(compiler_state):
                 compiler_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
         if _ != ERROR:
             data = '"'
             if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                 compiler_state.pos += len(data)
-                _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+                return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_dotname(compiler_state):
@@ -1384,10 +1382,10 @@ def rule_dotname(compiler_state):
                 compiler_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
         last_variable = append_named_action(last_variable, 'xs', _)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, action_33, pre_first_variable.next, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, action_33, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_nextname(compiler_state):
@@ -1399,13 +1397,13 @@ def rule_nextname(compiler_state):
     data = '.'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         _ = rule_name(compiler_state)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_wvar(compiler_state):
@@ -1417,13 +1415,13 @@ def rule_wvar(compiler_state):
     data = 'W['
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
         if compiler_state.pos != len(compiler_state.input_buffer):
             compiler_state.pos += 1
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
         else:
             _ = ERROR
         last_variable = append_named_action(last_variable, 'x', _)
@@ -1431,11 +1429,11 @@ def rule_wvar(compiler_state):
             data = ']'
             if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
                 compiler_state.pos += len(data)
-                _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+                _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
             else:
                 _ = ERROR
             if _ != ERROR:
-                return Action(compiler_state, compiler_state.input_buffer, action_34, pre_first_variable.next, action_start_pos, compiler_state.pos)
+                return Action(compiler_state.input_buffer, action_34, pre_first_variable.next, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_stringinner(compiler_state):
@@ -1454,11 +1452,11 @@ def rule_stringinner(compiler_state):
     if _ != ERROR:
         if compiler_state.pos != len(compiler_state.input_buffer):
             compiler_state.pos += 1
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_stringend(compiler_state):
@@ -1470,11 +1468,11 @@ def rule_stringend(compiler_state):
     data = '"'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_charstring(compiler_state):
@@ -1495,11 +1493,11 @@ def rule_charstring(compiler_state):
                 compiler_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
         if _ != ERROR:
             _ = rule_quote(compiler_state)
             if _ != ERROR:
-                return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+                return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_quote(compiler_state):
@@ -1511,11 +1509,11 @@ def rule_quote(compiler_state):
     data = '\''
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_innercharstring(compiler_state):
@@ -1527,11 +1525,11 @@ def rule_innercharstring(compiler_state):
     data = '\\\''
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, action_35, pre_first_variable.next, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, action_35, pre_first_variable.next, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1546,11 +1544,11 @@ def rule_innercharstring(compiler_state):
     if _ != ERROR:
         if compiler_state.pos != len(compiler_state.input_buffer):
             compiler_state.pos += 1
-            _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
+            _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)
         else:
             _ = ERROR
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_name(compiler_state):
@@ -1571,9 +1569,9 @@ def rule_name(compiler_state):
                 compiler_state.pos = star_pos
                 break
             star_last = append_named_action(star_last, None, _)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
         if _ != ERROR:
-            return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+            return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_char(compiler_state):
@@ -1585,11 +1583,11 @@ def rule_char(compiler_state):
     data = 'a'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1597,11 +1595,11 @@ def rule_char(compiler_state):
     data = 'b'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1609,11 +1607,11 @@ def rule_char(compiler_state):
     data = 'c'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1621,11 +1619,11 @@ def rule_char(compiler_state):
     data = 'd'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1633,11 +1631,11 @@ def rule_char(compiler_state):
     data = 'e'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1645,11 +1643,11 @@ def rule_char(compiler_state):
     data = 'f'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1657,11 +1655,11 @@ def rule_char(compiler_state):
     data = 'g'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1669,11 +1667,11 @@ def rule_char(compiler_state):
     data = 'h'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1681,11 +1679,11 @@ def rule_char(compiler_state):
     data = 'i'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1693,11 +1691,11 @@ def rule_char(compiler_state):
     data = 'j'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1705,11 +1703,11 @@ def rule_char(compiler_state):
     data = 'k'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1717,11 +1715,11 @@ def rule_char(compiler_state):
     data = 'l'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1729,11 +1727,11 @@ def rule_char(compiler_state):
     data = 'm'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1741,11 +1739,11 @@ def rule_char(compiler_state):
     data = 'n'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1753,11 +1751,11 @@ def rule_char(compiler_state):
     data = 'o'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1765,11 +1763,11 @@ def rule_char(compiler_state):
     data = 'p'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1777,11 +1775,11 @@ def rule_char(compiler_state):
     data = 'q'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1789,11 +1787,11 @@ def rule_char(compiler_state):
     data = 'r'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1801,11 +1799,11 @@ def rule_char(compiler_state):
     data = 's'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1813,11 +1811,11 @@ def rule_char(compiler_state):
     data = 't'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1825,11 +1823,11 @@ def rule_char(compiler_state):
     data = 'u'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1837,11 +1835,11 @@ def rule_char(compiler_state):
     data = 'v'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1849,11 +1847,11 @@ def rule_char(compiler_state):
     data = 'w'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1861,11 +1859,11 @@ def rule_char(compiler_state):
     data = 'x'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1873,11 +1871,11 @@ def rule_char(compiler_state):
     data = 'y'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1885,11 +1883,11 @@ def rule_char(compiler_state):
     data = 'z'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1897,11 +1895,11 @@ def rule_char(compiler_state):
     data = 'A'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1909,11 +1907,11 @@ def rule_char(compiler_state):
     data = 'B'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1921,11 +1919,11 @@ def rule_char(compiler_state):
     data = 'C'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1933,11 +1931,11 @@ def rule_char(compiler_state):
     data = 'D'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1945,11 +1943,11 @@ def rule_char(compiler_state):
     data = 'E'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1957,11 +1955,11 @@ def rule_char(compiler_state):
     data = 'F'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1969,11 +1967,11 @@ def rule_char(compiler_state):
     data = 'G'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1981,11 +1979,11 @@ def rule_char(compiler_state):
     data = 'H'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -1993,11 +1991,11 @@ def rule_char(compiler_state):
     data = 'I'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2005,11 +2003,11 @@ def rule_char(compiler_state):
     data = 'J'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2017,11 +2015,11 @@ def rule_char(compiler_state):
     data = 'K'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2029,11 +2027,11 @@ def rule_char(compiler_state):
     data = 'L'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2041,11 +2039,11 @@ def rule_char(compiler_state):
     data = 'M'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2053,11 +2051,11 @@ def rule_char(compiler_state):
     data = 'N'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2065,11 +2063,11 @@ def rule_char(compiler_state):
     data = 'O'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2077,11 +2075,11 @@ def rule_char(compiler_state):
     data = 'P'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2089,11 +2087,11 @@ def rule_char(compiler_state):
     data = 'Q'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2101,11 +2099,11 @@ def rule_char(compiler_state):
     data = 'R'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2113,11 +2111,11 @@ def rule_char(compiler_state):
     data = 'S'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2125,11 +2123,11 @@ def rule_char(compiler_state):
     data = 'T'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2137,11 +2135,11 @@ def rule_char(compiler_state):
     data = 'U'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2149,11 +2147,11 @@ def rule_char(compiler_state):
     data = 'V'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2161,11 +2159,11 @@ def rule_char(compiler_state):
     data = 'W'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2173,11 +2171,11 @@ def rule_char(compiler_state):
     data = 'X'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2185,11 +2183,11 @@ def rule_char(compiler_state):
     data = 'Y'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2197,11 +2195,11 @@ def rule_char(compiler_state):
     data = 'Z'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_space(compiler_state):
@@ -2220,9 +2218,9 @@ def rule_space(compiler_state):
             compiler_state.pos = star_pos
             break
         star_last = append_named_action(star_last, None, _)
-    _ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
+    _ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 def rule_spacechar(compiler_state):
@@ -2234,11 +2232,11 @@ def rule_spacechar(compiler_state):
     data = ' '
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     compiler_state.pos = or_backtrack_pos
     action_start_pos = compiler_state.pos
     pre_first_variable = Variable()
@@ -2246,17 +2244,17 @@ def rule_spacechar(compiler_state):
     data = '\n'
     if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:
         compiler_state.pos += len(data)
-        _ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
+        _ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)
     else:
         _ = ERROR
     if _ != ERROR:
-        return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
+        return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)
     return ERROR
 
 if __name__ == '__main__':
     compiler_state = CompilerState(sys.stdin.read())
-    run_action(rule_main(compiler_state))
+    run_action(rule_main(compiler_state), compiler_state)
     for chunk_buffer, action in compiler_state.placeholders:
         compiler_state.current_chunk_buffer = chunk_buffer
-        run_action(action)
+        run_action(action, compiler_state)
     render_chunk_buffer(compiler_state.output_chunk_buffer)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 9a5080f..fc4faec 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -16,8 +16,7 @@ file = rule*:xs space !. -> {
     <
     "\n"
     "class Action:\n" >
-        "def __init__(self, compiler_state, input_buffer, function, variable, start, end):\n" >
-            "self.compiler_state = compiler_state\n"
+        "def __init__(self, input_buffer, function, variable, start, end):\n" >
             "self.function = function\n"
             "self.variable = variable\n"
             "self.input_buffer = input_buffer\n"
@@ -51,21 +50,21 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
-    "def run_action(action):\n" >
+    "def run_action(action, state):\n" >
         "if action.function is None:\n" >
             "if action.variable is None:\n" >
-                "action.compiler_state.current_chunk_buffer.last = append_data(action.compiler_state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n"
+                "state.current_chunk_buffer.last = append_data(state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)\n"
             <
             "else:\n" >
                 "variable = action.variable\n"
                 "while variable:\n" >
-                    "run_action(variable.action)\n"
+                    "run_action(variable.action, state)\n"
                     "variable = variable.next\n"
                 <
             <
         <
         "else:\n" >
-            "action.function(action.compiler_state, action.variable)\n"
+            "action.function(state, action.variable)\n"
         <
     <
     "\n"
@@ -131,10 +130,10 @@ file = rule*:xs space !. -> {
     xs
     "if __name__ == '__main__':\n" >
         "compiler_state = CompilerState(sys.stdin.read())\n"
-        "run_action(rule_main(compiler_state))\n"
+        "run_action(rule_main(compiler_state), compiler_state)\n"
         "for chunk_buffer, action in compiler_state.placeholders:\n" >
             "compiler_state.current_chunk_buffer = chunk_buffer\n"
-            "run_action(action)\n"
+            "run_action(action, compiler_state)\n"
         <
         "render_chunk_buffer(compiler_state.output_chunk_buffer)\n"
     <
@@ -212,7 +211,7 @@ matchExprRepeat =
             <
             "star_last = append_named_action(star_last, None, _)\n"
         <
-        "_ = Action(compiler_state, compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n"
+        "_ = Action(compiler_state.input_buffer, None, star_pre_first.next, star_start_pos, compiler_state.pos)\n"
     }
     | matchExprPrimitive:x -> {
         x
@@ -226,7 +225,7 @@ matchExprPrimitive =
     | '.'          -> {
         "if compiler_state.pos != len(compiler_state.input_buffer):\n" >
             "compiler_state.pos += 1\n"
-            "_ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n"
+            "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-1, compiler_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -236,7 +235,7 @@ matchExprPrimitive =
         "data = " x "\n"
         "if compiler_state.input_buffer[compiler_state.pos:compiler_state.pos+len(data)] == data:\n" >
             "compiler_state.pos += len(data)\n"
-            "_ = Action(compiler_state, compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n"
+            "_ = Action(compiler_state.input_buffer, None, None, compiler_state.pos-len(data), compiler_state.pos)\n"
         <
         "else:\n" >
             "_ = ERROR\n"
@@ -254,10 +253,10 @@ action =
             <
             "\n"
         }
-        "return Action(compiler_state, compiler_state.input_buffer, action_" W[0] ", pre_first_variable.next, action_start_pos, compiler_state.pos)\n"
+        "return Action(compiler_state.input_buffer, action_" W[0] ", pre_first_variable.next, action_start_pos, compiler_state.pos)\n"
     }
     | -> {
-        "return Action(compiler_state, compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n"
+        "return Action(compiler_state.input_buffer, None, None, action_start_pos, compiler_state.pos)\n"
     }
     ;
 
@@ -281,7 +280,7 @@ actionexpr =
         "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, str(" x "), 0)\n"
     }
     | space name:x -> {
-        "run_action(lookup_action(variable, '" x "'))\n"
+        "run_action(lookup_action(variable, '" x "'), compiler_state)\n"
     }
     | space placeholder:x -> {
         #inc(W[1] 1)
@@ -293,7 +292,7 @@ actionexpr =
             "\n"
         }
         "new_chunk_buffer = ChunkBuffer()\n"
-        "compiler_state.placeholders.append((new_chunk_buffer, Action(compiler_state, compiler_state.input_buffer, placeholder_" W[1] ", variable, 0, 0)))\n"
+        "compiler_state.placeholders.append((new_chunk_buffer, Action(compiler_state.input_buffer, placeholder_" W[1] ", variable, 0, 0)))\n"
         "compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)\n"
     }
     | space string:x -> {

commit 3f5cdd79df47443b3bf811a9c7af175a0154e642
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:38:10 2025 +0100

    Cleaner order

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 1968e87..9bfe872 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -22,18 +22,6 @@ class Action:
         self.end = end
         self.len = end-start
 
-def run_action(action):
-    if action.function is None:
-        if action.variable is None:
-            action.compiler_state.current_chunk_buffer.last = append_data(action.compiler_state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)
-        else:
-            variable = action.variable
-            while variable:
-                run_action(variable.action)
-                variable = variable.next
-    else:
-        action.function(action.compiler_state, action.variable)
-
 class ChunkBuffer:
     def __init__(self):
         self.pre_start = Chunk()
@@ -46,6 +34,24 @@ class Chunk:
         self.chunk_buffer = None
         self.indentation_delta = None
 
+class Variable:
+    def __init__(self):
+        self.next = None
+        self.name = None
+        self.action = None
+
+def run_action(action):
+    if action.function is None:
+        if action.variable is None:
+            action.compiler_state.current_chunk_buffer.last = append_data(action.compiler_state.current_chunk_buffer.last, action.input_buffer[action.start:action.end], 0)
+        else:
+            variable = action.variable
+            while variable:
+                run_action(variable.action)
+                variable = variable.next
+    else:
+        action.function(action.compiler_state, action.variable)
+
 def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):
     next_chunk = Chunk()
     next_chunk.next = chunk.next
@@ -55,12 +61,6 @@ def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):
     chunk.next = next_chunk
     return next_chunk
 
-class Variable:
-    def __init__(self):
-        self.next = None
-        self.name = None
-        self.action = None
-
 def append_named_action(variable, name, action):
     next_variable = Variable()
     next_variable.next = variable.next
@@ -135,6 +135,36 @@ def action_2(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class ChunkBuffer:\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.pre_start = Chunk()\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.last = self.pre_start\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Chunk:\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.next = None\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.data = None\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.chunk_buffer = None\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.indentation_delta = None\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Variable:\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.next = None\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.name = None\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.action = None\n", 0)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
+    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def run_action(action):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "if action.function is None:\n", 0)
@@ -159,26 +189,6 @@ def action_2(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class ChunkBuffer:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.pre_start = Chunk()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.last = self.pre_start\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Chunk:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.next = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.data = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.chunk_buffer = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.indentation_delta = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_chunk = Chunk()\n", 0)
@@ -190,16 +200,6 @@ def action_2(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "return next_chunk\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Variable:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.next = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.name = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.action = None\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def append_named_action(variable, name, action):\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "next_variable = Variable()\n", 0)
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 934abf2..9a5080f 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -27,6 +27,30 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
+    "class ChunkBuffer:\n" >
+        "def __init__(self):\n" >
+            "self.pre_start = Chunk()\n"
+            "self.last = self.pre_start\n"
+        <
+    <
+    "\n"
+    "class Chunk:\n" >
+        "def __init__(self):\n" >
+            "self.next = None\n"
+            "self.data = None\n"
+            "self.chunk_buffer = None\n"
+            "self.indentation_delta = None\n"
+        <
+    <
+    "\n"
+    "class Variable:\n" >
+        "def __init__(self):\n" >
+            "self.next = None\n"
+            "self.name = None\n"
+            "self.action = None\n"
+        <
+    <
+    "\n"
     "def run_action(action):\n" >
         "if action.function is None:\n" >
             "if action.variable is None:\n" >
@@ -45,22 +69,6 @@ file = rule*:xs space !. -> {
         <
     <
     "\n"
-    "class ChunkBuffer:\n" >
-        "def __init__(self):\n" >
-            "self.pre_start = Chunk()\n"
-            "self.last = self.pre_start\n"
-        <
-    <
-    "\n"
-    "class Chunk:\n" >
-        "def __init__(self):\n" >
-            "self.next = None\n"
-            "self.data = None\n"
-            "self.chunk_buffer = None\n"
-            "self.indentation_delta = None\n"
-        <
-    <
-    "\n"
     "def append_data(chunk, data, indentation_delta, sub_chunk_buffer=None):\n" >
         "next_chunk = Chunk()\n"
         "next_chunk.next = chunk.next\n"
@@ -71,14 +79,6 @@ file = rule*:xs space !. -> {
         "return next_chunk\n"
     <
     "\n"
-    "class Variable:\n" >
-        "def __init__(self):\n" >
-            "self.next = None\n"
-            "self.name = None\n"
-            "self.action = None\n"
-        <
-    <
-    "\n"
     "def append_named_action(variable, name, action):\n" >
         "next_variable = Variable()\n"
         "next_variable.next = variable.next\n"

commit 39c4878bb43aa462174b8a412fcdc2393cf1872f
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:36:58 2025 +0100

    Better name

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index e99a667..1968e87 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -7,7 +7,7 @@ class CompilerState:
         self.output_chunk_buffer = ChunkBuffer()
         self.current_chunk_buffer = self.output_chunk_buffer
         self.action_chunk_buffer = None
-        self.buffer_chunk_buffer = None
+        self.namedBuffers_chunk_buffer = None
         self.placeholder_chunk_buffer = None
         self.placeholders = []
         self.W = {}
@@ -114,7 +114,7 @@ def action_2(compiler_state, variable):
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.output_chunk_buffer = ChunkBuffer()\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.current_chunk_buffer = self.output_chunk_buffer\n", 0)
     new_chunk_buffer = ChunkBuffer()
-    compiler_state.buffer_chunk_buffer = new_chunk_buffer
+    compiler_state.namedBuffers_chunk_buffer = new_chunk_buffer
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 0, new_chunk_buffer)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.placeholders = []\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.W = {}\n", 0)
@@ -437,7 +437,7 @@ def action_21(compiler_state, variable):
     run_action(lookup_action(variable, 'ys'))
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "compiler_state.current_chunk_buffer = last_chunk_buffer\n", 0)
     last_chunk_buffer = compiler_state.current_chunk_buffer
-    chunk_buffer = compiler_state.buffer_chunk_buffer
+    chunk_buffer = compiler_state.namedBuffers_chunk_buffer
     compiler_state.current_chunk_buffer = chunk_buffer
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.", 0)
     run_action(lookup_action(variable, 'x'))
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 640394f..934abf2 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -9,7 +9,7 @@ file = rule*:xs space !. -> {
             "self.pos = 0\n"
             "self.output_chunk_buffer = ChunkBuffer()\n"
             "self.current_chunk_buffer = self.output_chunk_buffer\n"
-            <buffer
+            <namedBuffers
             "self.placeholders = []\n"
             "self.W = {}\n"
         <
@@ -268,7 +268,7 @@ actionexpr =
         "compiler_state.current_chunk_buffer = chunk_buffer\n"
         ys
         "compiler_state.current_chunk_buffer = last_chunk_buffer\n"
-        >buffer {
+        >namedBuffers {
             "self." x "_chunk_buffer = None\n"
         }
     }

commit 4e71af0eb6fa8e94640706768d0197dd8b9b310f
Author: Rickard Lindberg <rickard@rickardlindberg.me>
Date:   Wed Oct 29 20:28:37 2025 +0100

    Get rid of unused buffers

diff --git a/07_improve_meta_compiler/rlmeta2.py b/07_improve_meta_compiler/rlmeta2.py
index 472d3dc..e99a667 100644
--- a/07_improve_meta_compiler/rlmeta2.py
+++ b/07_improve_meta_compiler/rlmeta2.py
@@ -1,21 +1,13 @@
 import sys
 
-class Buffer:
-    def __init__(self):
-        self.buffer = ''
-        self.indent = 0
-
 class CompilerState:
     def __init__(self, input_buffer):
         self.input_buffer = input_buffer
         self.pos = 0
         self.output_chunk_buffer = ChunkBuffer()
         self.current_chunk_buffer = self.output_chunk_buffer
-        self.action_buffer = Buffer()
         self.action_chunk_buffer = None
-        self.buffer_buffer = Buffer()
         self.buffer_chunk_buffer = None
-        self.placeholder_buffer = Buffer()
         self.placeholder_chunk_buffer = None
         self.placeholders = []
         self.W = {}
@@ -113,15 +105,6 @@ def action_2(compiler_state, variable):
     pass
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "import sys\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class Buffer:\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self):\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.buffer = ''\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.indent = 0\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', -1)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "class CompilerState:\n", 0)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, '', 1)
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "def __init__(self, input_buffer):\n", 0)
@@ -458,9 +441,6 @@ def action_21(compiler_state, variable):
     compiler_state.current_chunk_buffer = chunk_buffer
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.", 0)
     run_action(lookup_action(variable, 'x'))
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_buffer = Buffer()\n", 0)
-    compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "self.", 0)
-    run_action(lookup_action(variable, 'x'))
     compiler_state.current_chunk_buffer.last = append_data(compiler_state.current_chunk_buffer.last, "_chunk_buffer = None\n", 0)
     compiler_state.current_chunk_buffer = last_chunk_buffer
 
diff --git a/07_improve_meta_compiler/rlmeta2.rlmeta2 b/07_improve_meta_compiler/rlmeta2.rlmeta2
index 6dafdda..640394f 100644
--- a/07_improve_meta_compiler/rlmeta2.rlmeta2
+++ b/07_improve_meta_compiler/rlmeta2.rlmeta2
@@ -3,13 +3,6 @@ main = file:x -> { x };
 file = rule*:xs space !. -> {
     "import sys\n"
     "\n"
-    "class Buffer:\n" >
-        "def __init__(self):\n" >
-            "self.buffer = ''\n"
-            "self.indent = 0\n"
-        <
-    <
-    "\n"
     "class CompilerState:\n" >
         "def __init__(self, input_buffer):\n" >
             "self.input_buffer = input_buffer\n"
@@ -276,7 +269,6 @@ actionexpr =
         ys
         "compiler_state.current_chunk_buffer = last_chunk_buffer\n"
         >buffer {
-            "self." x "_buffer = Buffer()\n"
             "self." x "_chunk_buffer = None\n"
         }
     }