/* ./tests/suites/toyir/tsf_ir_different.c -- generated by tsf_define from ./tests/suites/toyir/tsf_ir_different.t */

#include "tsf_ir_different.h"
#include "tsf_define_helpers.h"
#include <stdio.h>

static tsf_type_t *DOperand__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DType__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DCodeOffset__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DVariableDecl__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProcedure__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProcedureDecl__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProcedureDefn__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProgramElement__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProgram__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__mov__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__add__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__alloc__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__ret__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__jump__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__call__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__call__args__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *int16__array__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__branchZero__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProcedureDefn__variables__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DVariableDecl__array__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProcedureDefn__code__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DInstruction__array__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProgram__globals__build_type(void) TSF_ATTRIBUTE_NOINLINE;
static tsf_type_t *DProgramElement__array__build_type(void) TSF_ATTRIBUTE_NOINLINE;

tsf_type_t *DOperand__build_type(void) {
    tsf_type_t *result = tsf_type_create_aoe(TSF_TK_INT16);
    return result;
}

tsf_type_t *DType__build_type(void) {
    tsf_type_t *result = tsf_type_create_aoe(TSF_TK_STRING);
    return result;
}

tsf_type_t *DCodeOffset__build_type(void) {
    tsf_type_t *result = tsf_type_create_aoe(TSF_TK_INT16);
    return result;
}

tsf_type_t *DVariableDecl__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_and_destructor_aoe(sizeof(DVariableDecl_t), (void(*)(void*))DVariableDecl__destruct);
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "type", DType__get_type, tsf_offsetof(DVariableDecl_t, type));
    tsf_type_set_name_aoe(&result, "DVariableDecl");
    return result;
}

tsf_type_t *DInstruction__build_type(void) {
    tsf_type_t *result = tsf_type_create_choice_with_native_map_aoe(&result, tsf_true, tsf_offsetof(DInstruction_t, value), tsf_offsetof(DInstruction_t, u), sizeof(DInstruction_t));
    tsf_choice_type_append_primitive_aoe(&result, "nop", TSF_TK_VOID);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "mov", DInstruction__mov__get_type);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "add", DInstruction__add__get_type);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "alloc", DInstruction__alloc__get_type);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "ret", DInstruction__ret__get_type);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "jump", DInstruction__jump__get_type);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "call", DInstruction__call__get_type);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "branchZero", DInstruction__branchZero__get_type);
    tsf_type_set_name_aoe(&result, "DInstruction");
    return result;
}

tsf_type_t *DInstruction__mov__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_aoe(sizeof(DInstruction__mov_t));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "dest", DOperand__get_type, tsf_offsetof(DInstruction__mov_t, dest));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "src", DOperand__get_type, tsf_offsetof(DInstruction__mov_t, src));
    tsf_type_set_name_aoe(&result, "DInstruction__mov");
    return result;
}

tsf_type_t *DInstruction__add__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_aoe(sizeof(DInstruction__add_t));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "dest", DOperand__get_type, tsf_offsetof(DInstruction__add_t, dest));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "src", DOperand__get_type, tsf_offsetof(DInstruction__add_t, src));
    tsf_type_set_name_aoe(&result, "DInstruction__add");
    return result;
}

tsf_type_t *DInstruction__alloc__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_and_destructor_aoe(sizeof(DInstruction__alloc_t), (void(*)(void*))DInstruction__alloc__destruct);
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "type", DType__get_type, tsf_offsetof(DInstruction__alloc_t, type));
    tsf_type_set_name_aoe(&result, "DInstruction__alloc");
    return result;
}

tsf_type_t *DInstruction__ret__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_aoe(sizeof(DInstruction__ret_t));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "src", DOperand__get_type, tsf_offsetof(DInstruction__ret_t, src));
    tsf_type_set_name_aoe(&result, "DInstruction__ret");
    return result;
}

tsf_type_t *DInstruction__jump__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_aoe(sizeof(DInstruction__jump_t));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "target", DCodeOffset__get_type, tsf_offsetof(DInstruction__jump_t, target));
    tsf_type_set_name_aoe(&result, "DInstruction__jump");
    return result;
}

tsf_type_t *DInstruction__call__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_and_destructor_aoe(sizeof(DInstruction__call_t), (void(*)(void*))DInstruction__call__destruct);
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "dest", DOperand__get_type, tsf_offsetof(DInstruction__call_t, dest));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "callee", DOperand__get_type, tsf_offsetof(DInstruction__call_t, callee));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "args", DInstruction__call__args__get_type, tsf_offsetof(DInstruction__call_t, args));
    tsf_type_set_name_aoe(&result, "DInstruction__call");
    return result;
}

tsf_type_t *int16__array__build_type(void) {
    tsf_type_t *result = tsf_type_create_array_aoe(tsf_type_create_aoe(TSF_TK_INT16));
    return result;
}

tsf_type_t *DInstruction__branchZero__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_aoe(sizeof(DInstruction__branchZero_t));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "src", DOperand__get_type, tsf_offsetof(DInstruction__branchZero_t, src));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "target", DCodeOffset__get_type, tsf_offsetof(DInstruction__branchZero_t, target));
    tsf_type_set_name_aoe(&result, "DInstruction__branchZero");
    return result;
}

tsf_type_t *DProcedure__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_and_destructor_aoe(sizeof(DProcedure_t), (void(*)(void*))DProcedure__destruct);
    tsf_struct_type_append_primitive_with_native_map_aoe(&result, "name", TSF_TK_STRING, tsf_offsetof(DProcedure_t, name));
    tsf_type_set_name_aoe(&result, "DProcedure");
    return result;
}

tsf_type_t *DProcedureDecl__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_and_destructor_aoe(sizeof(DProcedureDecl_t), (void(*)(void*))DProcedureDecl__destruct);
    tsf_struct_type_append_primitive_with_native_map_aoe(&result, "name", TSF_TK_STRING, tsf_offsetof(DProcedureDecl_t, name));
    tsf_type_set_name_aoe(&result, "DProcedureDecl");
    return result;
}

tsf_type_t *DProcedureDefn__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_and_destructor_aoe(sizeof(DProcedureDefn_t), (void(*)(void*))DProcedureDefn__destruct);
    tsf_struct_type_append_primitive_with_native_map_aoe(&result, "name", TSF_TK_STRING, tsf_offsetof(DProcedureDefn_t, name));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "variables", DProcedureDefn__variables__get_type, tsf_offsetof(DProcedureDefn_t, variables));
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "code", DProcedureDefn__code__get_type, tsf_offsetof(DProcedureDefn_t, code));
    tsf_type_set_name_aoe(&result, "DProcedureDefn");
    return result;
}

tsf_type_t *DVariableDecl__array__build_type(void) {
    tsf_type_t *result = tsf_type_create_array_aoe(tsf_type_dup(DVariableDecl__get_type()));
    return result;
}

tsf_type_t *DInstruction__array__build_type(void) {
    tsf_type_t *result = tsf_type_create_array_aoe(tsf_type_dup(DInstruction__get_type()));
    return result;
}

tsf_type_t *DProgramElement__build_type(void) {
    tsf_type_t *result = tsf_type_create_choice_with_native_map_aoe(&result, tsf_true, tsf_offsetof(DProgramElement_t, value), tsf_offsetof(DProgramElement_t, u), sizeof(DProgramElement_t));
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "procedureDecl", DProcedureDecl__get_type);
    tsf_choice_type_append_from_callback_and_dup_aoe(&result, "procedureDefn", DProcedureDefn__get_type);
    tsf_type_set_name_aoe(&result, "DProgramElement");
    return result;
}

tsf_type_t *DProgram__build_type(void) {
    tsf_type_t *result = tsf_type_create_struct_with_native_size_and_destructor_aoe(sizeof(DProgram_t), (void(*)(void*))DProgram__destruct);
    tsf_struct_type_append_from_callback_and_dup_with_native_map_aoe(&result, "globals", DProgram__globals__get_type, tsf_offsetof(DProgram_t, globals));
    tsf_type_set_name_aoe(&result, "DProgram");
    return result;
}

tsf_type_t *DProgramElement__array__build_type(void) {
    tsf_type_t *result = tsf_type_create_array_aoe(tsf_type_dup(DProgramElement__get_type()));
    return result;
}

tsf_type_t *DInstruction__call__args__build_type(void) {
    tsf_type_t *result = tsf_type_dup(int16__array__get_type());
    return result;
}

tsf_type_t *DProcedureDefn__variables__build_type(void) {
    tsf_type_t *result = tsf_type_dup(DVariableDecl__array__get_type());
    return result;
}

tsf_type_t *DProcedureDefn__code__build_type(void) {
    tsf_type_t *result = tsf_type_dup(DInstruction__array__get_type());
    return result;
}

tsf_type_t *DProgram__globals__build_type(void) {
    tsf_type_t *result = tsf_type_dup(DProgramElement__array__get_type());
    return result;
}

static tsf_type_t * volatile DOperand__type = NULL;
static tsf_genrtr_t * volatile DOperand__genrtr = NULL;
static tsf_parser_t * volatile DOperand__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DOperand__type__oc = PTHREAD_ONCE_INIT;
static void DOperand__type__builder(void) {
    DOperand__type = DOperand__build_type();
}
#else
static void *DOperand__type__builder(void) {
    return DOperand__build_type();
}
#endif
tsf_type_t *DOperand__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DOperand__type, DOperand__type__builder);
#else
    pthread_once(&DOperand__type__oc, DOperand__type__builder);
    return DOperand__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DOperand__genrtr__oc = PTHREAD_ONCE_INIT;
static void DOperand__genrtr__builder(void) {
    DOperand__genrtr = tsf_generator_create(DOperand__get_type());
}
#else
static void *DOperand__genrtr__builder(void) {
    return tsf_generator_create(DOperand__get_type());
}
#endif
tsf_genrtr_t *DOperand__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DOperand__genrtr, DOperand__genrtr__builder);
#else
    pthread_once(&DOperand__genrtr__oc, DOperand__genrtr__builder);
    return DOperand__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DOperand__parser__oc = PTHREAD_ONCE_INIT;
static void DOperand__parser__builder(void) {
    DOperand__parser = tsf_parser_create(DOperand__get_type());
}
#else
static void *DOperand__parser__builder(void) {
    return tsf_parser_create(DOperand__get_type());
}
#endif
tsf_parser_t *DOperand__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DOperand__parser, DOperand__parser__builder);
#else
    pthread_once(&DOperand__parser__oc, DOperand__parser__builder);
    return DOperand__parser;
#endif
}

tsf_bool_t DOperand__write(tsf_stream_file_output_t *out, DOperand_t *data) {
    return tsf_typed_data_write(out, DOperand__get_generator(), data);
}

DOperand_t *DOperand__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DOperand__get_parser());
}

tsf_bool_t DOperand__read_into(tsf_stream_file_input_t *in, DOperand_t *result) {
    return tsf_typed_data_read_into(in, DOperand__get_parser(), result);
}

static tsf_type_t * volatile DType__type = NULL;
static tsf_genrtr_t * volatile DType__genrtr = NULL;
static tsf_parser_t * volatile DType__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DType__type__oc = PTHREAD_ONCE_INIT;
static void DType__type__builder(void) {
    DType__type = DType__build_type();
}
#else
static void *DType__type__builder(void) {
    return DType__build_type();
}
#endif
tsf_type_t *DType__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DType__type, DType__type__builder);
#else
    pthread_once(&DType__type__oc, DType__type__builder);
    return DType__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DType__genrtr__oc = PTHREAD_ONCE_INIT;
static void DType__genrtr__builder(void) {
    DType__genrtr = tsf_generator_create(DType__get_type());
}
#else
static void *DType__genrtr__builder(void) {
    return tsf_generator_create(DType__get_type());
}
#endif
tsf_genrtr_t *DType__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DType__genrtr, DType__genrtr__builder);
#else
    pthread_once(&DType__genrtr__oc, DType__genrtr__builder);
    return DType__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DType__parser__oc = PTHREAD_ONCE_INIT;
static void DType__parser__builder(void) {
    DType__parser = tsf_parser_create(DType__get_type());
}
#else
static void *DType__parser__builder(void) {
    return tsf_parser_create(DType__get_type());
}
#endif
tsf_parser_t *DType__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DType__parser, DType__parser__builder);
#else
    pthread_once(&DType__parser__oc, DType__parser__builder);
    return DType__parser;
#endif
}
void DType__destruct(DType_t *data) {
    free(*data);
}

tsf_bool_t DType__write(tsf_stream_file_output_t *out, DType_t *data) {
    return tsf_typed_data_write(out, DType__get_generator(), data);
}

DType_t *DType__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DType__get_parser());
}

tsf_bool_t DType__read_into(tsf_stream_file_input_t *in, DType_t *result) {
    return tsf_typed_data_read_into(in, DType__get_parser(), result);
}

static tsf_type_t * volatile DCodeOffset__type = NULL;
static tsf_genrtr_t * volatile DCodeOffset__genrtr = NULL;
static tsf_parser_t * volatile DCodeOffset__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DCodeOffset__type__oc = PTHREAD_ONCE_INIT;
static void DCodeOffset__type__builder(void) {
    DCodeOffset__type = DCodeOffset__build_type();
}
#else
static void *DCodeOffset__type__builder(void) {
    return DCodeOffset__build_type();
}
#endif
tsf_type_t *DCodeOffset__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DCodeOffset__type, DCodeOffset__type__builder);
#else
    pthread_once(&DCodeOffset__type__oc, DCodeOffset__type__builder);
    return DCodeOffset__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DCodeOffset__genrtr__oc = PTHREAD_ONCE_INIT;
static void DCodeOffset__genrtr__builder(void) {
    DCodeOffset__genrtr = tsf_generator_create(DCodeOffset__get_type());
}
#else
static void *DCodeOffset__genrtr__builder(void) {
    return tsf_generator_create(DCodeOffset__get_type());
}
#endif
tsf_genrtr_t *DCodeOffset__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DCodeOffset__genrtr, DCodeOffset__genrtr__builder);
#else
    pthread_once(&DCodeOffset__genrtr__oc, DCodeOffset__genrtr__builder);
    return DCodeOffset__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DCodeOffset__parser__oc = PTHREAD_ONCE_INIT;
static void DCodeOffset__parser__builder(void) {
    DCodeOffset__parser = tsf_parser_create(DCodeOffset__get_type());
}
#else
static void *DCodeOffset__parser__builder(void) {
    return tsf_parser_create(DCodeOffset__get_type());
}
#endif
tsf_parser_t *DCodeOffset__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DCodeOffset__parser, DCodeOffset__parser__builder);
#else
    pthread_once(&DCodeOffset__parser__oc, DCodeOffset__parser__builder);
    return DCodeOffset__parser;
#endif
}

tsf_bool_t DCodeOffset__write(tsf_stream_file_output_t *out, DCodeOffset_t *data) {
    return tsf_typed_data_write(out, DCodeOffset__get_generator(), data);
}

DCodeOffset_t *DCodeOffset__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DCodeOffset__get_parser());
}

tsf_bool_t DCodeOffset__read_into(tsf_stream_file_input_t *in, DCodeOffset_t *result) {
    return tsf_typed_data_read_into(in, DCodeOffset__get_parser(), result);
}

static tsf_type_t * volatile DVariableDecl__type = NULL;
static tsf_genrtr_t * volatile DVariableDecl__genrtr = NULL;
static tsf_parser_t * volatile DVariableDecl__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DVariableDecl__type__oc = PTHREAD_ONCE_INIT;
static void DVariableDecl__type__builder(void) {
    DVariableDecl__type = DVariableDecl__build_type();
}
#else
static void *DVariableDecl__type__builder(void) {
    return DVariableDecl__build_type();
}
#endif
tsf_type_t *DVariableDecl__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DVariableDecl__type, DVariableDecl__type__builder);
#else
    pthread_once(&DVariableDecl__type__oc, DVariableDecl__type__builder);
    return DVariableDecl__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DVariableDecl__genrtr__oc = PTHREAD_ONCE_INIT;
static void DVariableDecl__genrtr__builder(void) {
    DVariableDecl__genrtr = tsf_generator_create(DVariableDecl__get_type());
}
#else
static void *DVariableDecl__genrtr__builder(void) {
    return tsf_generator_create(DVariableDecl__get_type());
}
#endif
tsf_genrtr_t *DVariableDecl__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DVariableDecl__genrtr, DVariableDecl__genrtr__builder);
#else
    pthread_once(&DVariableDecl__genrtr__oc, DVariableDecl__genrtr__builder);
    return DVariableDecl__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DVariableDecl__parser__oc = PTHREAD_ONCE_INIT;
static void DVariableDecl__parser__builder(void) {
    DVariableDecl__parser = tsf_parser_create(DVariableDecl__get_type());
}
#else
static void *DVariableDecl__parser__builder(void) {
    return tsf_parser_create(DVariableDecl__get_type());
}
#endif
tsf_parser_t *DVariableDecl__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DVariableDecl__parser, DVariableDecl__parser__builder);
#else
    pthread_once(&DVariableDecl__parser__oc, DVariableDecl__parser__builder);
    return DVariableDecl__parser;
#endif
}
void DVariableDecl__destruct(DVariableDecl_t *data) {
    DType__destruct(&data->type);
}

tsf_bool_t DVariableDecl__write(tsf_stream_file_output_t *out, DVariableDecl_t *data) {
    return tsf_typed_data_write(out, DVariableDecl__get_generator(), data);
}

DVariableDecl_t *DVariableDecl__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DVariableDecl__get_parser());
}

tsf_bool_t DVariableDecl__read_into(tsf_stream_file_input_t *in, DVariableDecl_t *result) {
    return tsf_typed_data_read_into(in, DVariableDecl__get_parser(), result);
}

static tsf_type_t * volatile DInstruction__type = NULL;
static tsf_genrtr_t * volatile DInstruction__genrtr = NULL;
static tsf_parser_t * volatile DInstruction__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__type__builder(void) {
    DInstruction__type = DInstruction__build_type();
}
#else
static void *DInstruction__type__builder(void) {
    return DInstruction__build_type();
}
#endif
tsf_type_t *DInstruction__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__type, DInstruction__type__builder);
#else
    pthread_once(&DInstruction__type__oc, DInstruction__type__builder);
    return DInstruction__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__genrtr__oc = PTHREAD_ONCE_INIT;
static void DInstruction__genrtr__builder(void) {
    DInstruction__genrtr = tsf_generator_create(DInstruction__get_type());
}
#else
static void *DInstruction__genrtr__builder(void) {
    return tsf_generator_create(DInstruction__get_type());
}
#endif
tsf_genrtr_t *DInstruction__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DInstruction__genrtr, DInstruction__genrtr__builder);
#else
    pthread_once(&DInstruction__genrtr__oc, DInstruction__genrtr__builder);
    return DInstruction__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__parser__oc = PTHREAD_ONCE_INIT;
static void DInstruction__parser__builder(void) {
    DInstruction__parser = tsf_parser_create(DInstruction__get_type());
}
#else
static void *DInstruction__parser__builder(void) {
    return tsf_parser_create(DInstruction__get_type());
}
#endif
tsf_parser_t *DInstruction__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DInstruction__parser, DInstruction__parser__builder);
#else
    pthread_once(&DInstruction__parser__oc, DInstruction__parser__builder);
    return DInstruction__parser;
#endif
}
void DInstruction__destruct(DInstruction_t *data) {
    switch (data->value) {
    case 3:
        DInstruction__alloc__destruct(&data->u.alloc);
        break;
    case 6:
        DInstruction__call__destruct(&data->u.call);
        break;
    default:
        break;
    }
}

tsf_bool_t DInstruction__write(tsf_stream_file_output_t *out, DInstruction_t *data) {
    return tsf_typed_data_write(out, DInstruction__get_generator(), data);
}

DInstruction_t *DInstruction__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DInstruction__get_parser());
}

tsf_bool_t DInstruction__read_into(tsf_stream_file_input_t *in, DInstruction_t *result) {
    return tsf_typed_data_read_into(in, DInstruction__get_parser(), result);
}

static tsf_type_t * volatile DProcedure__type = NULL;
static tsf_genrtr_t * volatile DProcedure__genrtr = NULL;
static tsf_parser_t * volatile DProcedure__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedure__type__oc = PTHREAD_ONCE_INIT;
static void DProcedure__type__builder(void) {
    DProcedure__type = DProcedure__build_type();
}
#else
static void *DProcedure__type__builder(void) {
    return DProcedure__build_type();
}
#endif
tsf_type_t *DProcedure__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProcedure__type, DProcedure__type__builder);
#else
    pthread_once(&DProcedure__type__oc, DProcedure__type__builder);
    return DProcedure__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedure__genrtr__oc = PTHREAD_ONCE_INIT;
static void DProcedure__genrtr__builder(void) {
    DProcedure__genrtr = tsf_generator_create(DProcedure__get_type());
}
#else
static void *DProcedure__genrtr__builder(void) {
    return tsf_generator_create(DProcedure__get_type());
}
#endif
tsf_genrtr_t *DProcedure__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DProcedure__genrtr, DProcedure__genrtr__builder);
#else
    pthread_once(&DProcedure__genrtr__oc, DProcedure__genrtr__builder);
    return DProcedure__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedure__parser__oc = PTHREAD_ONCE_INIT;
static void DProcedure__parser__builder(void) {
    DProcedure__parser = tsf_parser_create(DProcedure__get_type());
}
#else
static void *DProcedure__parser__builder(void) {
    return tsf_parser_create(DProcedure__get_type());
}
#endif
tsf_parser_t *DProcedure__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DProcedure__parser, DProcedure__parser__builder);
#else
    pthread_once(&DProcedure__parser__oc, DProcedure__parser__builder);
    return DProcedure__parser;
#endif
}
void DProcedure__destruct(DProcedure_t *data) {
    free(*&data->name);
}

tsf_bool_t DProcedure__write(tsf_stream_file_output_t *out, DProcedure_t *data) {
    return tsf_typed_data_write(out, DProcedure__get_generator(), data);
}

DProcedure_t *DProcedure__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DProcedure__get_parser());
}

tsf_bool_t DProcedure__read_into(tsf_stream_file_input_t *in, DProcedure_t *result) {
    return tsf_typed_data_read_into(in, DProcedure__get_parser(), result);
}

static tsf_type_t * volatile DProcedureDecl__type = NULL;
static tsf_genrtr_t * volatile DProcedureDecl__genrtr = NULL;
static tsf_parser_t * volatile DProcedureDecl__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDecl__type__oc = PTHREAD_ONCE_INIT;
static void DProcedureDecl__type__builder(void) {
    DProcedureDecl__type = DProcedureDecl__build_type();
}
#else
static void *DProcedureDecl__type__builder(void) {
    return DProcedureDecl__build_type();
}
#endif
tsf_type_t *DProcedureDecl__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProcedureDecl__type, DProcedureDecl__type__builder);
#else
    pthread_once(&DProcedureDecl__type__oc, DProcedureDecl__type__builder);
    return DProcedureDecl__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDecl__genrtr__oc = PTHREAD_ONCE_INIT;
static void DProcedureDecl__genrtr__builder(void) {
    DProcedureDecl__genrtr = tsf_generator_create(DProcedureDecl__get_type());
}
#else
static void *DProcedureDecl__genrtr__builder(void) {
    return tsf_generator_create(DProcedureDecl__get_type());
}
#endif
tsf_genrtr_t *DProcedureDecl__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DProcedureDecl__genrtr, DProcedureDecl__genrtr__builder);
#else
    pthread_once(&DProcedureDecl__genrtr__oc, DProcedureDecl__genrtr__builder);
    return DProcedureDecl__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDecl__parser__oc = PTHREAD_ONCE_INIT;
static void DProcedureDecl__parser__builder(void) {
    DProcedureDecl__parser = tsf_parser_create(DProcedureDecl__get_type());
}
#else
static void *DProcedureDecl__parser__builder(void) {
    return tsf_parser_create(DProcedureDecl__get_type());
}
#endif
tsf_parser_t *DProcedureDecl__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DProcedureDecl__parser, DProcedureDecl__parser__builder);
#else
    pthread_once(&DProcedureDecl__parser__oc, DProcedureDecl__parser__builder);
    return DProcedureDecl__parser;
#endif
}
void DProcedureDecl__destruct(DProcedureDecl_t *data) {
    free(*&data->name);
}

tsf_bool_t DProcedureDecl__write(tsf_stream_file_output_t *out, DProcedureDecl_t *data) {
    return tsf_typed_data_write(out, DProcedureDecl__get_generator(), data);
}

DProcedureDecl_t *DProcedureDecl__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DProcedureDecl__get_parser());
}

tsf_bool_t DProcedureDecl__read_into(tsf_stream_file_input_t *in, DProcedureDecl_t *result) {
    return tsf_typed_data_read_into(in, DProcedureDecl__get_parser(), result);
}

static tsf_type_t * volatile DProcedureDefn__type = NULL;
static tsf_genrtr_t * volatile DProcedureDefn__genrtr = NULL;
static tsf_parser_t * volatile DProcedureDefn__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDefn__type__oc = PTHREAD_ONCE_INIT;
static void DProcedureDefn__type__builder(void) {
    DProcedureDefn__type = DProcedureDefn__build_type();
}
#else
static void *DProcedureDefn__type__builder(void) {
    return DProcedureDefn__build_type();
}
#endif
tsf_type_t *DProcedureDefn__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProcedureDefn__type, DProcedureDefn__type__builder);
#else
    pthread_once(&DProcedureDefn__type__oc, DProcedureDefn__type__builder);
    return DProcedureDefn__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDefn__genrtr__oc = PTHREAD_ONCE_INIT;
static void DProcedureDefn__genrtr__builder(void) {
    DProcedureDefn__genrtr = tsf_generator_create(DProcedureDefn__get_type());
}
#else
static void *DProcedureDefn__genrtr__builder(void) {
    return tsf_generator_create(DProcedureDefn__get_type());
}
#endif
tsf_genrtr_t *DProcedureDefn__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DProcedureDefn__genrtr, DProcedureDefn__genrtr__builder);
#else
    pthread_once(&DProcedureDefn__genrtr__oc, DProcedureDefn__genrtr__builder);
    return DProcedureDefn__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDefn__parser__oc = PTHREAD_ONCE_INIT;
static void DProcedureDefn__parser__builder(void) {
    DProcedureDefn__parser = tsf_parser_create(DProcedureDefn__get_type());
}
#else
static void *DProcedureDefn__parser__builder(void) {
    return tsf_parser_create(DProcedureDefn__get_type());
}
#endif
tsf_parser_t *DProcedureDefn__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DProcedureDefn__parser, DProcedureDefn__parser__builder);
#else
    pthread_once(&DProcedureDefn__parser__oc, DProcedureDefn__parser__builder);
    return DProcedureDefn__parser;
#endif
}
void DProcedureDefn__destruct(DProcedureDefn_t *data) {
    free(*&data->name);
    DProcedureDefn__variables__destruct(&data->variables);
    DProcedureDefn__code__destruct(&data->code);
}

tsf_bool_t DProcedureDefn__write(tsf_stream_file_output_t *out, DProcedureDefn_t *data) {
    return tsf_typed_data_write(out, DProcedureDefn__get_generator(), data);
}

DProcedureDefn_t *DProcedureDefn__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DProcedureDefn__get_parser());
}

tsf_bool_t DProcedureDefn__read_into(tsf_stream_file_input_t *in, DProcedureDefn_t *result) {
    return tsf_typed_data_read_into(in, DProcedureDefn__get_parser(), result);
}

static tsf_type_t * volatile DProgramElement__type = NULL;
static tsf_genrtr_t * volatile DProgramElement__genrtr = NULL;
static tsf_parser_t * volatile DProgramElement__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgramElement__type__oc = PTHREAD_ONCE_INIT;
static void DProgramElement__type__builder(void) {
    DProgramElement__type = DProgramElement__build_type();
}
#else
static void *DProgramElement__type__builder(void) {
    return DProgramElement__build_type();
}
#endif
tsf_type_t *DProgramElement__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProgramElement__type, DProgramElement__type__builder);
#else
    pthread_once(&DProgramElement__type__oc, DProgramElement__type__builder);
    return DProgramElement__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgramElement__genrtr__oc = PTHREAD_ONCE_INIT;
static void DProgramElement__genrtr__builder(void) {
    DProgramElement__genrtr = tsf_generator_create(DProgramElement__get_type());
}
#else
static void *DProgramElement__genrtr__builder(void) {
    return tsf_generator_create(DProgramElement__get_type());
}
#endif
tsf_genrtr_t *DProgramElement__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DProgramElement__genrtr, DProgramElement__genrtr__builder);
#else
    pthread_once(&DProgramElement__genrtr__oc, DProgramElement__genrtr__builder);
    return DProgramElement__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgramElement__parser__oc = PTHREAD_ONCE_INIT;
static void DProgramElement__parser__builder(void) {
    DProgramElement__parser = tsf_parser_create(DProgramElement__get_type());
}
#else
static void *DProgramElement__parser__builder(void) {
    return tsf_parser_create(DProgramElement__get_type());
}
#endif
tsf_parser_t *DProgramElement__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DProgramElement__parser, DProgramElement__parser__builder);
#else
    pthread_once(&DProgramElement__parser__oc, DProgramElement__parser__builder);
    return DProgramElement__parser;
#endif
}
void DProgramElement__destruct(DProgramElement_t *data) {
    switch (data->value) {
    case 0:
        DProcedureDecl__destruct(&data->u.procedureDecl);
        break;
    case 1:
        DProcedureDefn__destruct(&data->u.procedureDefn);
        break;
    default:
        break;
    }
}

tsf_bool_t DProgramElement__write(tsf_stream_file_output_t *out, DProgramElement_t *data) {
    return tsf_typed_data_write(out, DProgramElement__get_generator(), data);
}

DProgramElement_t *DProgramElement__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DProgramElement__get_parser());
}

tsf_bool_t DProgramElement__read_into(tsf_stream_file_input_t *in, DProgramElement_t *result) {
    return tsf_typed_data_read_into(in, DProgramElement__get_parser(), result);
}

static tsf_type_t * volatile DProgram__type = NULL;
static tsf_genrtr_t * volatile DProgram__genrtr = NULL;
static tsf_parser_t * volatile DProgram__parser = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgram__type__oc = PTHREAD_ONCE_INIT;
static void DProgram__type__builder(void) {
    DProgram__type = DProgram__build_type();
}
#else
static void *DProgram__type__builder(void) {
    return DProgram__build_type();
}
#endif
tsf_type_t *DProgram__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProgram__type, DProgram__type__builder);
#else
    pthread_once(&DProgram__type__oc, DProgram__type__builder);
    return DProgram__type;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgram__genrtr__oc = PTHREAD_ONCE_INIT;
static void DProgram__genrtr__builder(void) {
    DProgram__genrtr = tsf_generator_create(DProgram__get_type());
}
#else
static void *DProgram__genrtr__builder(void) {
    return tsf_generator_create(DProgram__get_type());
}
#endif
tsf_genrtr_t *DProgram__get_generator(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_genrtr_t*)tsf_init_pointer((void**)&DProgram__genrtr, DProgram__genrtr__builder);
#else
    pthread_once(&DProgram__genrtr__oc, DProgram__genrtr__builder);
    return DProgram__genrtr;
#endif
}

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgram__parser__oc = PTHREAD_ONCE_INIT;
static void DProgram__parser__builder(void) {
    DProgram__parser = tsf_parser_create(DProgram__get_type());
}
#else
static void *DProgram__parser__builder(void) {
    return tsf_parser_create(DProgram__get_type());
}
#endif
tsf_parser_t *DProgram__get_parser(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_parser_t*)tsf_init_pointer((void**)&DProgram__parser, DProgram__parser__builder);
#else
    pthread_once(&DProgram__parser__oc, DProgram__parser__builder);
    return DProgram__parser;
#endif
}
void DProgram__destruct(DProgram_t *data) {
    DProgram__globals__destruct(&data->globals);
}

tsf_bool_t DProgram__write(tsf_stream_file_output_t *out, DProgram_t *data) {
    return tsf_typed_data_write(out, DProgram__get_generator(), data);
}

DProgram_t *DProgram__read(tsf_stream_file_input_t *in) {
    return tsf_typed_data_read(in, DProgram__get_parser());
}

tsf_bool_t DProgram__read_into(tsf_stream_file_input_t *in, DProgram_t *result) {
    return tsf_typed_data_read_into(in, DProgram__get_parser(), result);
}

static tsf_type_t * volatile DInstruction__mov__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__mov__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__mov__type__builder(void) {
    DInstruction__mov__type = DInstruction__mov__build_type();
}
#else
static void *DInstruction__mov__type__builder(void) {
    return DInstruction__mov__build_type();
}
#endif
tsf_type_t *DInstruction__mov__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__mov__type, DInstruction__mov__type__builder);
#else
    pthread_once(&DInstruction__mov__type__oc, DInstruction__mov__type__builder);
    return DInstruction__mov__type;
#endif
}

static tsf_type_t * volatile DInstruction__add__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__add__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__add__type__builder(void) {
    DInstruction__add__type = DInstruction__add__build_type();
}
#else
static void *DInstruction__add__type__builder(void) {
    return DInstruction__add__build_type();
}
#endif
tsf_type_t *DInstruction__add__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__add__type, DInstruction__add__type__builder);
#else
    pthread_once(&DInstruction__add__type__oc, DInstruction__add__type__builder);
    return DInstruction__add__type;
#endif
}

static tsf_type_t * volatile DInstruction__alloc__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__alloc__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__alloc__type__builder(void) {
    DInstruction__alloc__type = DInstruction__alloc__build_type();
}
#else
static void *DInstruction__alloc__type__builder(void) {
    return DInstruction__alloc__build_type();
}
#endif
tsf_type_t *DInstruction__alloc__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__alloc__type, DInstruction__alloc__type__builder);
#else
    pthread_once(&DInstruction__alloc__type__oc, DInstruction__alloc__type__builder);
    return DInstruction__alloc__type;
#endif
}
void DInstruction__alloc__destruct(DInstruction__alloc_t *data) {
    DType__destruct(&data->type);
}

static tsf_type_t * volatile DInstruction__ret__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__ret__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__ret__type__builder(void) {
    DInstruction__ret__type = DInstruction__ret__build_type();
}
#else
static void *DInstruction__ret__type__builder(void) {
    return DInstruction__ret__build_type();
}
#endif
tsf_type_t *DInstruction__ret__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__ret__type, DInstruction__ret__type__builder);
#else
    pthread_once(&DInstruction__ret__type__oc, DInstruction__ret__type__builder);
    return DInstruction__ret__type;
#endif
}

static tsf_type_t * volatile DInstruction__jump__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__jump__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__jump__type__builder(void) {
    DInstruction__jump__type = DInstruction__jump__build_type();
}
#else
static void *DInstruction__jump__type__builder(void) {
    return DInstruction__jump__build_type();
}
#endif
tsf_type_t *DInstruction__jump__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__jump__type, DInstruction__jump__type__builder);
#else
    pthread_once(&DInstruction__jump__type__oc, DInstruction__jump__type__builder);
    return DInstruction__jump__type;
#endif
}

static tsf_type_t * volatile DInstruction__call__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__call__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__call__type__builder(void) {
    DInstruction__call__type = DInstruction__call__build_type();
}
#else
static void *DInstruction__call__type__builder(void) {
    return DInstruction__call__build_type();
}
#endif
tsf_type_t *DInstruction__call__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__call__type, DInstruction__call__type__builder);
#else
    pthread_once(&DInstruction__call__type__oc, DInstruction__call__type__builder);
    return DInstruction__call__type;
#endif
}
void DInstruction__call__destruct(DInstruction__call_t *data) {
    DInstruction__call__args__destruct(&data->args);
}

static tsf_type_t * volatile DInstruction__call__args__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__call__args__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__call__args__type__builder(void) {
    DInstruction__call__args__type = DInstruction__call__args__build_type();
}
#else
static void *DInstruction__call__args__type__builder(void) {
    return DInstruction__call__args__build_type();
}
#endif
tsf_type_t *DInstruction__call__args__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__call__args__type, DInstruction__call__args__type__builder);
#else
    pthread_once(&DInstruction__call__args__type__oc, DInstruction__call__args__type__builder);
    return DInstruction__call__args__type;
#endif
}
void DInstruction__call__args__destruct(DInstruction__call__args_t *data) {
    int16__array__destruct(data);
}

static tsf_type_t * volatile int16__array__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t int16__array__type__oc = PTHREAD_ONCE_INIT;
static void int16__array__type__builder(void) {
    int16__array__type = int16__array__build_type();
}
#else
static void *int16__array__type__builder(void) {
    return int16__array__build_type();
}
#endif
tsf_type_t *int16__array__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&int16__array__type, int16__array__type__builder);
#else
    pthread_once(&int16__array__type__oc, int16__array__type__builder);
    return int16__array__type;
#endif
}
void int16__array__destruct(int16__array_t *data) {
    free(data->data);
}

static tsf_type_t * volatile DInstruction__branchZero__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__branchZero__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__branchZero__type__builder(void) {
    DInstruction__branchZero__type = DInstruction__branchZero__build_type();
}
#else
static void *DInstruction__branchZero__type__builder(void) {
    return DInstruction__branchZero__build_type();
}
#endif
tsf_type_t *DInstruction__branchZero__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__branchZero__type, DInstruction__branchZero__type__builder);
#else
    pthread_once(&DInstruction__branchZero__type__oc, DInstruction__branchZero__type__builder);
    return DInstruction__branchZero__type;
#endif
}

static tsf_type_t * volatile DProcedureDefn__variables__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDefn__variables__type__oc = PTHREAD_ONCE_INIT;
static void DProcedureDefn__variables__type__builder(void) {
    DProcedureDefn__variables__type = DProcedureDefn__variables__build_type();
}
#else
static void *DProcedureDefn__variables__type__builder(void) {
    return DProcedureDefn__variables__build_type();
}
#endif
tsf_type_t *DProcedureDefn__variables__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProcedureDefn__variables__type, DProcedureDefn__variables__type__builder);
#else
    pthread_once(&DProcedureDefn__variables__type__oc, DProcedureDefn__variables__type__builder);
    return DProcedureDefn__variables__type;
#endif
}
void DProcedureDefn__variables__destruct(DProcedureDefn__variables_t *data) {
    DVariableDecl__array__destruct(data);
}

static tsf_type_t * volatile DVariableDecl__array__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DVariableDecl__array__type__oc = PTHREAD_ONCE_INIT;
static void DVariableDecl__array__type__builder(void) {
    DVariableDecl__array__type = DVariableDecl__array__build_type();
}
#else
static void *DVariableDecl__array__type__builder(void) {
    return DVariableDecl__array__build_type();
}
#endif
tsf_type_t *DVariableDecl__array__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DVariableDecl__array__type, DVariableDecl__array__type__builder);
#else
    pthread_once(&DVariableDecl__array__type__oc, DVariableDecl__array__type__builder);
    return DVariableDecl__array__type;
#endif
}
void DVariableDecl__array__destruct(DVariableDecl__array_t *data) {
    uint32_t i;
    for (i = data->len; i--;)
        DVariableDecl__destruct((data->data + i));
    free(data->data);
}

static tsf_type_t * volatile DProcedureDefn__code__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProcedureDefn__code__type__oc = PTHREAD_ONCE_INIT;
static void DProcedureDefn__code__type__builder(void) {
    DProcedureDefn__code__type = DProcedureDefn__code__build_type();
}
#else
static void *DProcedureDefn__code__type__builder(void) {
    return DProcedureDefn__code__build_type();
}
#endif
tsf_type_t *DProcedureDefn__code__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProcedureDefn__code__type, DProcedureDefn__code__type__builder);
#else
    pthread_once(&DProcedureDefn__code__type__oc, DProcedureDefn__code__type__builder);
    return DProcedureDefn__code__type;
#endif
}
void DProcedureDefn__code__destruct(DProcedureDefn__code_t *data) {
    DInstruction__array__destruct(data);
}

static tsf_type_t * volatile DInstruction__array__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DInstruction__array__type__oc = PTHREAD_ONCE_INIT;
static void DInstruction__array__type__builder(void) {
    DInstruction__array__type = DInstruction__array__build_type();
}
#else
static void *DInstruction__array__type__builder(void) {
    return DInstruction__array__build_type();
}
#endif
tsf_type_t *DInstruction__array__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DInstruction__array__type, DInstruction__array__type__builder);
#else
    pthread_once(&DInstruction__array__type__oc, DInstruction__array__type__builder);
    return DInstruction__array__type;
#endif
}
void DInstruction__array__destruct(DInstruction__array_t *data) {
    uint32_t i;
    for (i = data->len; i--;)
        DInstruction__destruct((data->data + i));
    free(data->data);
}

static tsf_type_t * volatile DProgram__globals__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgram__globals__type__oc = PTHREAD_ONCE_INIT;
static void DProgram__globals__type__builder(void) {
    DProgram__globals__type = DProgram__globals__build_type();
}
#else
static void *DProgram__globals__type__builder(void) {
    return DProgram__globals__build_type();
}
#endif
tsf_type_t *DProgram__globals__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProgram__globals__type, DProgram__globals__type__builder);
#else
    pthread_once(&DProgram__globals__type__oc, DProgram__globals__type__builder);
    return DProgram__globals__type;
#endif
}
void DProgram__globals__destruct(DProgram__globals_t *data) {
    DProgramElement__array__destruct(data);
}

static tsf_type_t * volatile DProgramElement__array__type = NULL;

#ifndef TSF_HAVE_INIT_POINTER
static pthread_once_t DProgramElement__array__type__oc = PTHREAD_ONCE_INIT;
static void DProgramElement__array__type__builder(void) {
    DProgramElement__array__type = DProgramElement__array__build_type();
}
#else
static void *DProgramElement__array__type__builder(void) {
    return DProgramElement__array__build_type();
}
#endif
tsf_type_t *DProgramElement__array__get_type(void) {
#ifdef TSF_HAVE_INIT_POINTER
    return (tsf_type_t*)tsf_init_pointer((void**)&DProgramElement__array__type, DProgramElement__array__type__builder);
#else
    pthread_once(&DProgramElement__array__type__oc, DProgramElement__array__type__builder);
    return DProgramElement__array__type;
#endif
}
void DProgramElement__array__destruct(DProgramElement__array_t *data) {
    uint32_t i;
    for (i = data->len; i--;)
        DProgramElement__destruct((data->data + i));
    free(data->data);
}